1，Swift继续使用Object-C原有的一套线程，包括三种多线程编程技术：
（1）NSThread
（2）Cocoa NSOperation（NSOperation和NSOperationQueue）
（3）Grand Central Dispath（GCD）
2，本文着重介绍Grand Central Dispath（GCD）
|
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）获取系统存在的全局队列
|
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
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块
|
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，暂停或者继续队列
|
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 一次执行
|
1
2
3
4
5
6
|
//往dispatch_get_global_queue队列中添加代码块，只执行一次var predicate:dispatch_once_t = 0dispatch_once(&predicate, { () -> Void in //只执行一次，可用于创建单例 println("work")}) |
7，dispatch_after 延迟调用
|
1
2
3
4
5
6
|
//延时2秒执行let delta = 2.0 * Double(NSEC_PER_SEC)let dtime = dispatch_time(DISPATCH_TIME_NOW, Int64(delta))dispatch_after(dtime, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) { () -> Void in println("延时2秒执行")} |
8，多个任务全部结束后做一个全部结束的处理
|
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)//定义一个groupvar 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最加到指定队列中
|
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，信号，信号量
|
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 i in 1...20{ dispatch_async(queue,{ () -> Void in println("\(i)") })}//使用信号量保证正确性//创建一个初始计数值为1的信号var semaphore:dispatch_semaphore_t = dispatch_semaphore_create(1)for i 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) })} |
Swift - 多线程实现方式（3） - Grand Central Dispatch（GCD）
原文：http://www.cnblogs.com/Free-Thinker/p/4841139.html