2017-10-06 01:00:05 m0_38016385 阅读数 153
  • iOS移动开发从入门到精通(Xcode11 & Swift5)

    【课程特点】 学习iOS开发,请选本套课程,理由如下: 1、180节大容量课程:包含了iOS开发中的大部分实用技能; 2、创新的教学模式:手把手教您iOS开发技术,一看就懂,一学就会; 3、贴心的操作提示:让您的眼睛始终处于操作的焦点位置,不用再满屏找光标; 4、语言简洁精练:瞄准问题的核心所在,减少对思维的干扰,并节省您宝贵的时间; 【课程内容】 本视频教程拥有180节课程,包含iOS开发的方方面面:iOS开发基础理论知识、 视图、视图控制器、多媒体、数据处理、常用插件、信用卡卡号识别、自动化测试、网络访问、多线程、ShareSDK社会化分享、CoreImage、CoreText、CoreML机器学习、ARKit增强现实、面部检测、Storyboard技巧、关键帧动画、本地通知、陀螺仪相机定位设备、本地化、通过IAP内购实现营利、App上传与审核等超多干货! 

    2625 人正在学习 去看看 李发展

swift多线程

segue的一个技巧

在故事版里面任何建立会和controller交互的string,比如segue的identifier,可以在controller中使用一个struct来装载它们。

private struct storyboard{
    static let showPicture = "show picture"
}

zooming(delegation)

首先要把UIViewController代理他scrollview。Delegate表示将一个对象的部分功能转交给另一个对象。比如对象A希望对象B知道将要发生或已经发生某件事情,对象A可以把对象B的引用存为一个实例变量。这个对象B称为委托。当事件发生时,它检查委托对象是否实现了与该事件相适应的方法。如果已经实现,则调用该方法。

注意要在self(UIViewController)大类后,标明实现UIScrollViewDelegate。

@IBOutlet weak var ScrollView: UIScrollView! {
    didSet{
        ScrollView.contentSize = imageView.frame.size
        ScrollView.delegate = self
    }
}

func viewForZooming(in scrollView: UIScrollView) -> UIView? {
    return imageView
}

然后需要设置以下两个参数

ScrollView.minimumZoomScale = 0.03
ScrollView.maximumZoomScale = 1.0

extension

extension用于扩展已经存在的类。比如你要在UIViewController里面增加一些函数或者方法,可以用如下的方法。

extension UIViewController {
    var someVar
    func someFuntion
}

然后就可以直接使用。比如FaceViewController.someVar或者FaceViewController.someFunction。

multithreading

IOS中的多线程主要是用queue来处理的。queue可以是serial或者concurrent。Main Queue是IOS中的主要的队列,这个序列处理所有的UI activity,而且是serial的,serial主要是为了保持显示的秩序性。

let queue: dispatch_queue_t = dispatch_get_main_queue()
dispatch_async(queue) {
/*do what you want*/
}

上面是处理main queue的方法,要处理非main queue使用下列的方法。

dispatch_async(queue) {
/*do what you want non-UI*/
    dispatch_async(dispatch_get_main_queue()) {
    }
}

对于concurrent的queue有以下几种priority。
这里写图片描述

图片的开销只有真正需要显示的时候才下载哦!可以使用view.window != nil语句来判断。

我们可以按照这样的方式来改进fetchImage函数。

 func fetchImage(){
    if let url =  imageURL{
       DispatchQueue.global(qos: .userInitiated).async { // 1
            let imageData = try! Data(contentsOf: url)
            DispatchQueue.main.async { // 2
                if imageData != nil
                {
                    self.image = UIImage(data: imageData)
                }
            }
        }
    }
}

注意到image前面加入了一个image,这是因为image是这个类的一个属性,而这个代码写在了一个闭包里面。所以他需要知道这个属性是否需要时刻保持在堆里面,这个self就是起到提示的作用。

这样一来,UI就可以流畅自如的跳转了,但是图片有可能因为非常大而显示空白的页面,所以从交互的角度上讲需要有一些动画来提示用户现在正在loading。

只需要在左侧把activity indicator拖进去storyboard就可以了。不过需要注意的是层级结构。indicator必须放在scroll view的下面。

这里写图片描述

使用下列代码控制动画的开始和结束。

indicator.startAnimating()
indicator.stopAnimating()

解决一开始页面在detail

首先把UIViewController设置deleate为self,然后使用以下函数来控制条件。

func splitViewController(_ splitViewController: UISplitViewController, collapseSecondary secondaryViewController: UIViewController, onto primaryViewController: UIViewController) -> Bool {
    if let a = secondaryViewController as? ImageViewController {
        if a.imageURL == nil {
            return true
        }
    }
    return false
} 

使用代码segue

不再单独拉空间,而是在controller统一segue。

这里写图片描述

然后通过action的方式链接view和controlelr,并且加入以下代码。

@IBAction func showImage(_ sender: UIButton) {
    performSegue(withIdentifier: storyboard.showPicture, sender: sender)
}
2016-03-02 15:55:47 zh_2608 阅读数 534
  • iOS移动开发从入门到精通(Xcode11 & Swift5)

    【课程特点】 学习iOS开发,请选本套课程,理由如下: 1、180节大容量课程:包含了iOS开发中的大部分实用技能; 2、创新的教学模式:手把手教您iOS开发技术,一看就懂,一学就会; 3、贴心的操作提示:让您的眼睛始终处于操作的焦点位置,不用再满屏找光标; 4、语言简洁精练:瞄准问题的核心所在,减少对思维的干扰,并节省您宝贵的时间; 【课程内容】 本视频教程拥有180节课程,包含iOS开发的方方面面:iOS开发基础理论知识、 视图、视图控制器、多媒体、数据处理、常用插件、信用卡卡号识别、自动化测试、网络访问、多线程、ShareSDK社会化分享、CoreImage、CoreText、CoreML机器学习、ARKit增强现实、面部检测、Storyboard技巧、关键帧动画、本地通知、陀螺仪相机定位设备、本地化、通过IAP内购实现营利、App上传与审核等超多干货! 

    2625 人正在学习 去看看 李发展
1,Swift继续使用Object-C原有的一套线程,包括三种多线程编程技术:
(1)NSThread
(2)Cocoa NSOperation(NSOperation和NSOperationQueue)
(3)Grand Central Dispath(GCD)

2,本文着重介绍NSThread
NSTread在三种多线程技术中是最轻量级的,但需要自己管理线程的生命周期和线程同步。线程同步对数据的加锁会有一定的系统开销。

3,NSThread的两种创建方式
(1)直接创建线程并且自动运行线程
(2)先创建一个线程对象,然后手动运行线程,在运行线程操作之前可以设置线程的优先级等线程信息。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import UIKit
 
class ViewControllerUIViewController {
 
    override func viewDidLoad() {
        super.viewDidLoad()
         
        //方式1:使用类方法
        NSThread.detachNewThreadSelector("downloadImage", toTarget: self, withObject: nil)
         
        //方式2:实例方法-便利构造器
        var myThread:NSThread NSThread(target: self, selector: "downloadImage", object: nil)
        myThread.start()
    }
     
    //定义一个下载图片的方法,线程调用
    func downloadImage(){
        var imageUrl = "http://hangge.com/blog/images/logo.png"
        var data = NSData(contentsOfURL: NSURL(string: imageUrl)!, options: nil, error: nil)
        println(data?.length)
    }
     
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
}

4,线程同步
线程同步方法通过锁来实现,每个线程都只用一个锁,这个锁与一个特定的线程关联。下面演示两个线程之间的同步。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
import UIKit
 
class ViewControllerUIViewController {
     
    //定义两个线程
    var thread1:NSThread?
    var thread2:NSThread?
     
    //定义两个线程条件,用于锁住线程
    let condition1 = NSCondition()
    let condition2 = NSCondition()
 
    override func viewDidLoad() {
        super.viewDidLoad()
         
        thread2 = NSThread(target: self, selector: "method2:", object: nil)
        thread1 = NSThread(target: self, selector: "method1:", object: nil)
        thread1?.start()
    }
     
    //定义两方法,用于两个线程调用
    func method1(sender:AnyObject){
        for var i=0; i<10; i++ {
            print("NSThread 1 running \(i)")
            sleep(1)
             
            if i == 2 {
                thread2?.start() //启动线程2
                 
                //本线程(thread1)锁定
                condition1.lock()
                condition1.wait()
                condition1.unlock()
            }
        }
             
        print("NSThread 1 over")
         
        //线程2激活
        condition2.signal()
    }
     
    //方法2
    func method2(sender:AnyObject){
        for var i=0; i<10; i++ {
            print("NSThread 2 running \(i)")
            sleep(1)
             
            if i == 2 {
                //线程1激活
                condition1.signal()
                 
                //本线程(thread2)锁定
                condition2.lock()
                condition2.wait()
                condition2.unlock()
            }
        }
         
         print("NSThread 2 over")
    }
     
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
}
输出结果:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
NSThread 1 running 0
NSThread 1 running 1
NSThread 1 running 2
NSThread 2 running 0
NSThread 2 running 1
NSThread 2 running 2
NSThread 1 running 3
NSThread 1 running 4
NSThread 1 running 5
NSThread 1 running 6
NSThread 1 running 7
NSThread 1 running 8
NSThread 1 running 9
NSThread 1 over
NSThread 2 running 3
NSThread 2 running 4
NSThread 2 running 5
NSThread 2 running 6
NSThread 2 running 7
NSThread 2 running 8
NSThread 2 running 9
NSThread 2 over

2,本文着重介绍Cocoa NSOperation
Cocoa NSOperation不需要关心线程管理和数据同步的事情,可以把精力放在自己需要执行的操作上。相关的类有NSOperation和NSOperationQueue。其中NSOperation是个抽象类,使用它必须用它的子类,可以实现它或者使用它定义好的子类:NSBlockOperation。创建NSOperation子类的对象,把对象添加到NSOperationQueue队列里执行。

3,使用NSOperation的两种方式
(1)直接用定义好的子类:NSBlockOperation。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import UIKit
 
class ViewControllerUIViewController {
 
    override func viewDidLoad() {
        super.viewDidLoad()
         
        var operation:NSBlockOperation NSBlockOperation(block: { [weak selfin
            self?.downloadImage()
            return
        })
         
        //创建一个NSOperationQueue实例并添加operation
        var queue:NSOperationQueue NSOperationQueue()
        queue.addOperation(operation)
    }
     
    //定义一个下载图片的方法,线程调用
    func downloadImage(){
        var imageUrl = "http://hangge.com/blog/images/logo.png"
        var data = NSData(contentsOfURL: NSURL(string: imageUrl)!, options: nil, error: nil)
        println(data?.length)
    }
     
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }
}

(2)继承NSOperation 
然后把NSOperation子类的对象放入NSOperationQueue队列中,一旦这个对象被加入到队列,队列就开始处理这个对象,直到这个对象的所有操作完成,然后它被队列释放。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import UIKit
 
class ViewControllerUIViewController {
 
    override func viewDidLoad() {
        super.viewDidLoad()
         
        //创建线程对象
        var downloadImageOperation:DownloadImageOperation DownloadImageOperation()
         
        //创建一个NSOperationQueue实例并添加operation
        var queue:NSOperationQueue NSOperationQueue()
        queue.addOperation(downloadImageOperation)
    }  
    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
    }
}
 
class DownloadImageOperationNSOperation {
    override func main(){
        var imageUrl = "http://hangge.com/blog/images/logo.png"
        var data = NSData(contentsOfURL: NSURL(string: imageUrl)!, options: nil, error: nil)
        println(data?.length)
    }
}

4,设置运行队列并发数 
NSOperationQueue队列里可以加入很多个NSOperation,可以把NSOperationQueue看做一个线程池,可往线程池中添加操作(NSOperation)到队列中。
可以设置线程池中的线程数,也就是并发操作数。默认情况下是-1,-1表示没有限制,这样可以同时运行队列中的全部操作。
1
2
//设置并发数
queue.maxConcurrentOperationCount = 5

5,取消队列所有操作
1
2
//取消所有线程操作
queue.cancelAllOperations()

6,每个NSOperation完成都会有一个回调表示任务结束
1
2
3
4
5
6
7
//定义一个回调
var completionBlock:(() -> Void)?
//给operation设置回调
operation.completionBlock = completionBlock
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 4), dispatch_get_main_queue(), {
    println("Complete")
})

2,本文着重介绍Grand Central Dispath(GCD)
GCD是Apple开发的一个多核编程的解决方法,基本概念就是dispatch queue(调度队列),queue是一个对象,它可以接受任务,并将任务以先到先执行的顺序来执行。dispatch queue可以是并发的或串行的。GCD的底层依然是用线程实现,不过我们可以不用关注实现的细节。其优点有如下几点:
(1)易用:GCD比thread更简单易用。基于block的特效使它能极为简单地在不同代码作用域之间传递上下文。
(2)效率:GCD实现功能轻量,优雅,使得它在很多地方比专门创建消耗资源的线程更加实用且快捷。
(3)性能:GCD自动根据系统负载来增减线程数量,从而减少了上下文切换并增加了计算效率。
(4)安全:无需加锁或其他同步机制。

3,GCD三种创建队列的方法
(1)自己创建一个队列
第一个参数代表队列的名称,可以任意起名
第二个参数代表队列属于串行还是并行执行任务
串行队列一次只执行一个任务。一般用于按顺序同步访问,但我们可以创建任意数量的串行队列,各个串行队列之间是并发的。
并行队列的执行顺序与其加入队列的顺序相同。可以并发执行多个任务,但是执行完成的顺序是随机的。
1
2
3
4
5
//创建串行队列
var serial:dispatch_queue_t = dispatch_queue_create("serialQueue1"DISPATCH_QUEUE_SERIAL)
 
//创建并行队列
var concurrent:dispatch_queue_t = dispatch_queue_create("concurrentQueue1"DISPATCH_QUEUE_CONCURRENT)

(2)获取系统存在的全局队列 
Global Dispatch Queue有4个执行优先级:
DISPATCH_QUEUE_PRIORITY_HIGH  高
DISPATCH_QUEUE_PRIORITY_DEFAULT  正常
DISPATCH_QUEUE_PRIORITY_LOW  低
DISPATCH_QUEUE_PRIORITY_BACKGROUND 非常低的优先级(这个优先级只用于不太关心完成时间的真正的后台任务)
1
var globalQueue:dispatch_queue_t = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

(3)运行在主线程的Main Dispatch Queue 
正如名称中的Main一样,这是在主线程里执行的队列。应为主线程只有一个,所有这自然是串行队列。一起跟UI有关的操作必须放在主线程中执行。
1
var mainQueue:dispatch_queue_t = dispatch_get_main_queue()

4,添加任务到队列的两种方法 
(1)dispatch_async异步追加Block块(dispatch_async函数不做任何等待)
1
2
3
4
5
6
7
8
9
10
//添加异步代码块到dispatch_get_global_queue队列
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), { () -> Void in
    //处理耗时操作的代码块...
    println("do work")
     
    //操作完成,调用主线程来刷新界面
    dispatch_async(dispatch_get_main_queue(), { () -> Void in
        println("main refresh")
    })
})
(2)dispatch_sync同步追加Block块 
同步追加Block块,与上面相反。在追加Block结束之前,dispatch_sync函数会一直等待,等待队列前面的所有任务完成后才能执行追加的任务。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//添加同步代码块到dispatch_get_global_queue队列
//不会造成死锁,当会一直等待代码块执行完毕
dispatch_sync(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), { () -> Void in
    println("sync1")
})
println("end1")
 
 
//添加同步代码块到dispatch_get_main_queue队列
//会引起死锁
//因为在主线程里面添加一个任务,因为是同步,所以要等添加的任务执行完毕后才能继续走下去。但是新添加的任务排在
//队列的末尾,要执行完成必须等前面的任务执行完成,由此又回到了第一步,程序卡死
dispatch_sync(dispatch_get_main_queue(), { () -> Void in
    println("sync2")
})
println("end2")

5,暂停或者继续队列
这两个函数是异步的,而且只在不同的blocks之间生效,对已经正在执行的任务没有影响。
dispatch_suspend后,追加到Dispatch Queue中尚未执行的任务在此之后停止执行。
而dispatch_resume则使得这些任务能够继续执行。
1
2
3
4
5
6
//创建并行队列
var conQueue:dispatch_queue_t = dispatch_queue_create("concurrentQueue1"DISPATCH_QUEUE_CONCURRENT)
//暂停一个队列
dispatch_suspend(conQueue)
//继续队列
dispatch_resume(conQueue)

6,dispatch_once 一次执行
保证dispatch_once中的代码块在应用程序里面只执行一次,无论是不是多线程。因此其可以用来实现单例模式,安全,简洁,方便。
1
2
3
4
5
6
//往dispatch_get_global_queue队列中添加代码块,只执行一次
var predicate:dispatch_once_t = 0
dispatch_once(&predicate, { () -> Void in
    //只执行一次,可用于创建单例
    println("work")
})

7,dispatch_after 延迟调用
dispatch_after并不是在指定时间后执行任务处理,而是在指定时间后把任务追加到Dispatch Queue里面。因此会有少许延迟。注意,我们不能(直接)取消我们已经提交到dispatch_after里的代码。
1
2
3
4
5
6
//延时2秒执行
let delta = 2.0 * Double(NSEC_PER_SEC)
let dtime = dispatch_time(DISPATCH_TIME_NOWInt64(delta))
dispatch_after(dtime, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) { () -> Void in
    println("延时2秒执行")
}

8,多个任务全部结束后做一个全部结束的处理
dispatch_group_async:用来监视一组block对象的完成,你可以同步或异步地监视
dispatch_group_notify:用来汇总结果,所有任务结束汇总,不阻塞当前线程
dispatch_group_wait:等待直到所有任务执行结束,中途不能取消,阻塞当前线程
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//获取系统存在的全局队列
var queue:dispatch_queue_t = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
//定义一个group
var group:dispatch_group_t = dispatch_group_create()
//并发任务,顺序执行
dispatch_group_async(group, queue, {() -> Void in
    println("block1")
})
dispatch_group_async(group, queue, {() -> Void in
    println("block2")
})
dispatch_group_async(group, queue, {() -> Void in
    println("block3")
})
 
//所有任务执行结束汇总,不阻塞当前线程
dispatch_group_notify(group, dispatch_get_main_queue(), {() -> Void in
    println("group done")
})
 
//永久等待,直到所有任务执行结束,中途不能取消,阻塞当前线程
var result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER)
if result == 0{
    println("任务全部执行完成")
}else{
    println("某个任务还在执行")
}

8,dipatch_apply 指定次数的Block最加到指定队列中
dipatch_apply函数是dispatch_sync函数和Dispatch Group的关联API。按指定的次数将指定的Block追加到指定的Dispatch Queue中,并等待全部处理执行结束。
因为dispatch_apply函数也与dispatch_sync函数一样,会等待处理结束,因此推荐在dispatch_async函数中异步执行dispatch_apply函数。dispatch_apply函数可以实现高性能的循环迭代。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//获取系统存在的全局队列
var queue:dispatch_queue_t = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
 
//定义一个一步代码块
dispatch_async(queue, {() -> Void in
     
    //通过dispatch_apply,循环变量数组
    dispatch_apply(6, queue, {(index) -> Void in
        println(index)
    })
     
    //执行完毕,主线程更新
    dispatch_async(dispatch_get_main_queue(), {() -> Void in
        println("done")
    })
})

9,信号,信号量
dispatch_semaphore_create:用于创建信号量,可以指定初始化信号量计数值,这里我们默认1.
dispatch_semaphore_waite:会判断信号量,如果为1,则往下执行。如果是0,则等待。
dispatch_semaphore_signal:代表运行结束,信号量加1,有等待的任务这个时候才会继续执行。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
//获取系统存在的全局队列
var queue:dispatch_queue_t = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
 
//当并行执行的任务更新数据时,会产生数据不一样的情况
for in 1...20
{
    dispatch_async(queue,{ () -> Void in
        println("\(i)")
    })
}
 
//使用信号量保证正确性
//创建一个初始计数值为1的信号
var semaphore:dispatch_semaphore_t = dispatch_semaphore_create(1)
for in 1...20
{
    dispatch_async(queue,{ () -> Void in
        //永久等待,直到Dispatch Semaphore的计数值 >= 1
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER)
        println("\(i)")
        //发信号,使原来的信号计数值+1
        dispatch_semaphore_signal(semaphore)
    })
}

原文出自:www.hangge.com  转载请保留原文链接:http://www.hangge.com/blog/cache/detail_745.html
2016-06-08 08:53:50 walkerwqp 阅读数 2758
  • iOS移动开发从入门到精通(Xcode11 & Swift5)

    【课程特点】 学习iOS开发,请选本套课程,理由如下: 1、180节大容量课程:包含了iOS开发中的大部分实用技能; 2、创新的教学模式:手把手教您iOS开发技术,一看就懂,一学就会; 3、贴心的操作提示:让您的眼睛始终处于操作的焦点位置,不用再满屏找光标; 4、语言简洁精练:瞄准问题的核心所在,减少对思维的干扰,并节省您宝贵的时间; 【课程内容】 本视频教程拥有180节课程,包含iOS开发的方方面面:iOS开发基础理论知识、 视图、视图控制器、多媒体、数据处理、常用插件、信用卡卡号识别、自动化测试、网络访问、多线程、ShareSDK社会化分享、CoreImage、CoreText、CoreML机器学习、ARKit增强现实、面部检测、Storyboard技巧、关键帧动画、本地通知、陀螺仪相机定位设备、本地化、通过IAP内购实现营利、App上传与审核等超多干货! 

    2625 人正在学习 去看看 李发展

GCD 是一种非常方便的使用多线程的方式。通过使用 GCD,我们可以在确保尽量简单的语法的前提下进行灵活的多线程编程。在 “复杂必死” 的多线程编程中,保持简单就是避免错误的金科玉律。好消息是在 Swift 中是可以无缝使用 GCD 的 API 的,而且得益于闭包特性的加入,使用起来比之前在 Objective-C 中更加简单方便。在这里我不打算花费很多时间介绍 GCD 的语法和要素,如果这么做的话就可以专门为 GCD 写上一节了。在下面我给出了一个日常里最通常会使用到的例子 (说这个例子能覆盖到日常的 GCD 使用的 50% 以上也不为过),来展示一下 Swift 里的 GCD 调用会是什么样子:

01 // 创建目标队列
02 let workingQueue = dispatch_queue_create("my_queue", nil)
03  
04 // 派发到刚创建的队列中,GCD 会负责进行线程调度
05 dispatch_async(workingQueue) {
06     // 在 workingQueue 中异步进行
07     print("努力工作")
08     NSThread.sleepForTimeInterval(2)  // 模拟两秒的执行时间
09  
10     dispatch_async(dispatch_get_main_queue()) {
11         // 返回到主线程更新 UI
12         print("结束工作,更新 UI")
13     }
14 }
因为 UIKit 是只能在主线程工作的,如果我们在主线程进行繁重的工作的话,就会导致 app 出现 “卡死” 的现象:UI 不能更新,用户输入无法响应等等,是非常糟糕的用户体验。为了避免这种情况的出现,对于繁重 (如图像加滤镜等) 或会很长时间才能完成的 (如从网络下载图片) 处理,我们应该把它们放到后台线程进行,这样在用户看来 UI 还是可以交互的,也不会出现卡顿。在工作进行完成后,我们需要更新 UI 的话,必须回到主线程进行 (牢记 UI 相关的工作都需要在主线程执行,否则可能发生不可预知的错误)。

在日常的开发工作中,我们经常会遇到这样的需求:在 xx 秒后执行某个方法。比如切换界面 2 秒后开始播一段动画,或者提示框出现 3 秒后自动消失等等。以前在 Objective-C 中,我们可以使用一个 NSObject 的实例方法,-performSelector:withObject:afterDelay: 来指定在若干时间后执行某个 selector。在 Swift 2 之前,如果你新建一个 Swift 的项目,并且试图使用这个方法 (或者这个方法的其他一切变形) 的话,会发现这个方法并不存在。在 Swift 2 中虽然这一系列 performSelector 的方法被加回了标准库,但是由于 Swift 中创建一个 selector 并不是一件安全的事情 (你需要通过字符串来创建,这在之后代码改动时会很危险),所以最好尽可能的话避免使用这个方法。另外,原来的 performSelector: 这套东西在 ARC 下并不是安全的。ARC 为了确保参数在方法运行期间的存在,在无法准确确定参数内存情况的时候,会将输入参数在方法开始时先进行 retain,然后在最后 release。而对于 performSelector: 这个方法我们并没有机会为被调用的方法指定参数,于是被调用的 selector 的输入有可能会是指向未知的垃圾内存地址,然后...HOHO,要命的是这种崩溃还不能每次重现,想调试?见鬼去吧..


但是如果不论如何,我们都还想继续做延时调用的话应该怎么办呢?最容易想到的是使用 NSTimer 来创建一个若干秒后调用一次的计时器。但是这么做我们需要创建新的对象,和一个本来并不相干的 NSTimer 类扯上关系,同时也会用到 Objective-C 的运行时特性去查找方法等等,总觉着有点笨重。其实 GCD 里有一个很好用的延时调用我们可以加以利用写出很漂亮的方法来,那就是 dispatch_after。最简单的使用方法看起来是这样的:

1 let time: NSTimeInterval = 2.0
2 let delay = dispatch_time(DISPATCH_TIME_NOW,
3                          Int64(time * Double(NSEC_PER_SEC)))
4 dispatch_after(delay, dispatch_get_main_queue()) {
5     print("2 秒后输出")
6 }

代码非常简单,代码非常简单,并没什么值得详细说明的。只是每次写这么多的话也挺累的,在这里我们可以稍微将它封装的好用一些,最好再加上取消的功能。在 iOS 8 中 GCD 得到了惊人的进化,现在我们可以通过将一个 dispatch_block_t 对象传递给 dispatch_block_cancel,来取消一个正在等待执行的 block。取消一个任务这样的特性,这在以前是 NSOperation 的专利,但是现在我们使用 GCD 也能达到同样的目的了。这里我们将类似地来尝试实现 delay call 的取消,整个封装也许有点长,但我还是推荐一读。大家也可以把它当作练习材料检验一下自己的 Swift 基础语法的掌握和理解的情况:

01 import Foundation
02  
03 typealias Task = (cancel : Bool) -> Void
04  
05 func delay(time:NSTimeInterval, task:()->()) ->  Task? {
06  
07     func dispatch_later(block:()->()) {
08         dispatch_after(
09             dispatch_time(
10                 DISPATCH_TIME_NOW,
11                 Int64(time * Double(NSEC_PER_SEC))),
12             dispatch_get_main_queue(),