基本概念和Dispatch Queue

你的名字 2022-06-08 02:57 159阅读 0赞

# iOS的三种多线程技术　　　　　　　　　　　　　　　　　　　　 #

1.NSThread 每个NSThread对象对应一个线程，量级较轻（真正的多线程）

2.以下两点是苹果专门开发的“并发”技术，使得程序员可以不再去关心线程的具体使用问题

ØNSOperation/NSOperationQueue 面向对象的线程技术

ØGCD —— Grand Central Dispatch（派发） 是基于C语言的框架，可以充分利用多核，是苹果推荐使用的多线程技术

以上这三种编程方式从上到下，抽象度层次是从低到高的，抽象度越高的使用越简单，也是Apple最推荐使用的，在项目中很多框架技术分别使用了不同多线程技术。

# 2.三种多线程技术的对比　　　　　　　　　　　　　　　　　　　　　    #

•NSThread:

–优点：NSThread 比其他两个轻量级，使用简单

–缺点：需要自己管理线程的生命周期、线程同步、加锁、睡眠以及唤醒等。线程同步对数据的加锁会有一定的系统开销

•NSOperation：

–不需要关心线程管理，数据同步的事情，可以把精力放在自己需要执行的操作上

–NSOperation是面向对象的

•GCD：

–Grand Central Dispatch是由苹果开发的一个多核编程的解决方案。iOS4.0+才能使用，是替代NSThread， NSOperation的高效和强大的技术

–GCD是基于C语言的

**什么是GCD？**

Grand Central Dispatch或者GCD，是一套低层API，提供了一种新的方法来进行并发程序编写。从基本功能上讲，GCD有点像NSOperationQueue，他们都允许程序将任务切分为多个单一任务然后提交至工作队列来并发地或者串行地执行。GCD比之NSOpertionQueue更底层更高效，并且它不是Cocoa框架的一部分。

除了代码的平行执行能力，GCD还提供高度集成的事件控制系统。可以设置句柄来响应文件描述符、mach ports（*Mach port* 用于 OS X上的进程间通讯）、进程、计时器、信号、用户生成事件。这些句柄通过GCD来并发执行。

GCD的API很大程度上基于block，当然，GCD也可以脱离block来使用，比如使用传统c机制提供函数指针和上下文指针。实践证明，当配合block使用时，GCD非常简单易用且能发挥其最大能力。

你可以在Mac上敲命令“man dispatch”来获取GCD的文档。

**为何使用?**

GCD提供很多超越传统多线程编程的优势：

1.  **易用:** GCD比之thread跟简单易用。由于GCD基于work unit而非像thread那样基于运算，所以GCD可以控制诸如*等待任务结束*、*监视文件描述符*、*周期执行代码以及工作挂起*等任务。基于block的血统导致它能极为简单得在不同代码作用域之间传递上下文。
2.  **效率:** GCD被实现得如此轻量和优雅，使得它在很多地方比之专门创建消耗资源的线程更实用且快速。这关系到易用性：导致GCD易用的原因有一部分在于你可以不用担心太多的效率问题而仅仅使用它就行了。
3.  **性能:** GCD自动根据系统负载来增减线程数量，这就减少了上下文切换以及增加了计算效率。

**Dispatch Objects**

尽管GCD是纯c语言的，但它被组建成面向对象的风格。GCD对象被称为dispatch object。Dispatch object像Cocoa对象一样是引用计数的。使用dispatch\_release和dispatch\_retain函数来操作dispatch object的引用计数来进行内存管理。但主意不像Cocoa对象，dispatch object并不参与垃圾回收系统，所以即使开启了GC，你也必须手动管理GCD对象的内存。

Dispatch queues 和 dispatch sources（后面会介绍到）可以被挂起和恢复，可以有一个相关联的任意上下文指针，可以有一个相关联的任务完成触发函数。可以查阅“man dispatch\_object”来获取这些功能的更多信息。

**Dispatch Queues**

GCD的基本概念就是dispatch queue。dispatch queue是一个对象，它可以接受任务，并将任务以先到先执行的顺序来执行。dispatch queue可以是并发的或串行的。并发任务会像NSOperationQueue那样基于系统负载来合适地并发进行，串行队列同一时间只执行单一任务。

GCD中有三种队列类型：

1.  **The main queue:** 与主线程功能相同。实际上，提交至main queue的任务会在主线程中执行。main queue可以调用dispatch\_get\_main\_queue()来获得。因为main queue是与主线程相关的，所以这是一个串行队列。
2.  **Global queues:** 全局队列是并发队列，并由整个进程共享。进程中存在三个全局队列：高、中（默认）、低三个优先级队列。可以调用dispatch\_get\_global\_queue函数传入优先级来访问队列。
3.  **用户队列:** 用户队列 (GCD并不这样称呼这种队列, 但是没有一个特定的名字来形容这种队列，所以我们称其为用户队列) 是用函数 `dispatch_queue_create` 创建的队列. 这些队列是串行的。正因为如此，它们可以用来完成同步机制, 有点像传统线程中的mutex。

> **\[objc\]**  [view plain][]   [copy][view plain]
> 
> 1.  Dispatch Queues的生成可以有这几种方式：  
> 2.    
> 3.  1. dispatch\_queue\_t queue = dispatch\_queue\_create("com.dispatch.serial", DISPATCH\_QUEUE\_SERIAL); //生成一个串行队列，队列中的block按照先进先出（FIFO）的顺序去执行，实际上为单线程执行。第一个参数是队列的名称，在调试程序时会非常有用，所有尽量不要重名了。  
> 4.    
> 5.  2. dispatch\_queue\_t queue = dispatch\_queue\_create("com.dispatch.concurrent", DISPATCH\_QUEUE\_CONCURRENT); //生成一个并发执行队列，block被分发到多个线程去执行  
> 6.    
> 7.  3. dispatch\_queue\_t queue = dispatch\_get\_global\_queue(DISPATCH\_QUEUE\_PRIORITY\_DEFAULT, 0); //获得程序进程缺省产生的并发队列，可设定优先级来选择高、中、低三个优先级队列。由于是系统默认生成的，所以无法调用dispatch\_resume()和dispatch\_suspend()来控制执行继续或中断。需要注意的是，三个队列不代表三个线程，可能会有更多的线程。并发队列可以根据实际情况来自动产生合理的线程数，也可理解为dispatch队列实现了一个线程池的管理，对于程序逻辑是透明的。  
> 8.    
> 9.  官网文档解释说共有三个并发队列，但实际还有一个更低优先级的队列，设置优先级为DISPATCH\_QUEUE\_PRIORITY\_BACKGROUND。Xcode调试时可以观察到正在使用的各个dispatch队列。  
> 10.   
> 11. 4. dispatch\_queue\_t queue = dispatch\_get\_main\_queue(); //获得主线程的dispatch队列，实际是一个串行队列。同样无法控制主线程dispatch队列的执行继续或中断。  
> 12.   
> 13. 接下来我们可以使用dispatch\_async或dispatch\_sync函数来加载需要运行的block。  
> 14.   
> 15. dispatch\_async(queue, ^\{  
> 16.   
> 17. 　　//block具体代码  
> 18.   
> 19. \}); //异步执行block，函数立即返回  
> 20.   
> 21. dispatch\_sync(queue, ^\{  
> 22.   
> 23. 　　//block具体代码  
> 24.   
> 25. \}); //同步执行block，函数不返回，一直等到block执行完毕。编译器会根据实际情况优化代码，所以有时候你会发现block其实还在当前线程上执行，并没用产生新线程。  
> 26.   
> 27. 实际编程经验告诉我们，尽可能避免使用dispatch\_sync，嵌套使用时还容易引起程序死锁。  
> 28.   
> 29. 如果queue1是一个串行队列的话，这段代码立即产生死锁：  
> 30.   
> 31.    dispatch\_sync(queue1, ^\{  
> 32.   
> 33.       dispatch\_sync(queue1, ^\{  
> 34.   
> 35. 　　　　......  
> 36.   
> 37. 　　\});  
> 38.   
> 39. 　　......  
> 40.   
> 41. 　\});   
> 42.   
> 43. 那实际运用中，一般可以用dispatch这样来写，常见的网络请求数据多线程执行模型：  
> 44.   
> 45. dispatch\_async(dispatch\_get\_global\_queue(DISPATCH\_QUEUE\_PRIORITY\_DEFAULT, 0), ^\{  
> 46.   
> 47. 　　//子线程中开始网络请求数据  
> 48.   
> 49. 　　//更新数据模型  
> 50.   
> 51. 　　dispatch\_sync(dispatch\_get\_main\_queue(), ^\{  
> 52.   
> 53. 　　　　//在主线程中更新UI代码  
> 54.   
> 55. 　　\});  
> 56.   
> 57. \});  
> 58.   
> 59. 程序的后台运行和UI更新代码紧凑，代码逻辑一目了然。  
> 60.   
> 61.    
> 62.   
> 63. dispatch队列是线程安全的，可以利用串行队列实现锁的功能。比如多线程写同一数据库，需要保持写入的顺序和每次写入的完整性，简单地利用串行队列即可实现：  
> 64.   
> 65. dispatch\_queue\_t queue1 = dispatch\_queue\_create("com.dispatch.writedb", DISPATCH\_QUEUE\_SERIAL);  
> 66.   
> 67. \- (**void**)writeDB:(**NSData** \*)data  
> 68.   
> 69. \{  
> 70.   
> 71. 　　dispatch\_async(queue1, ^\{  
> 72.   
> 73. 　　　　//write database  
> 74.   
> 75. 　　\});  
> 76.   
> 77. \}   
> 78.   
> 79. 下一次调用writeDB:必须等到上次调用完成后才能进行，保证writeDB:方法是线程安全的。   
> 80.   
> 81.    
> 82.   
> 83. dispatch队列还实现其它一些常用函数，包括：  
> 84.   
> 85. **void** dispatch\_apply(**size\_t** iterations, dispatch\_queue\_t queue, **void** (^block)(**size\_t**)); //重复执行block，需要注意的是这个方法是同步返回，也就是说等到所有block执行完毕才返回，如需异步返回则嵌套在dispatch\_async中来使用。多个block的运行是否并发或串行执行也依赖queue的是否并发或串行。  
> 86.   
> 87. **void** dispatch\_barrier\_async(dispatch\_queue\_t queue, dispatch\_block\_t block); //这个函数可以设置同步执行的block，它会等到在它加入队列之前的block执行完毕后，才开始执行。在它之后加入队列的block，则等到这个block执行完毕后才开始执行。  
> 88.   
> 89. **void** dispatch\_barrier\_sync(dispatch\_queue\_t queue, dispatch\_block\_t block); //同上，除了它是同步返回函数  
> 90.   
> 91. **void** dispatch\_after(dispatch\_time\_t when, dispatch\_queue\_t queue, dispatch\_block\_t block); //延迟执行block  
> 92.   
> 93. 最后再来看看dispatch队列的一个很有特色的函数：  
> 94.   
> 95. **void** dispatch\_set\_target\_queue(dispatch\_object\_t object, dispatch\_queue\_t queue);  
> 96.   
> 97. 它会把需要执行的任务对象指定到不同的队列中去处理，这个任务对象可以是dispatch队列，也可以是dispatch源（以后博文会介绍）。而且这个过程可以是动态的，可以实现队列的动态调度管理等等。比如说有两个队列dispatchA和dispatchB，这时把dispatchA指派到dispatchB：  
> 98.   
> 99. dispatch\_set\_target\_queue(dispatchA, dispatchB);  
> 100.   
> 101. 那么dispatchA上还未运行的block会在dispatchB上运行。这时如果暂停dispatchA运行：  
> 102.   
> 103. dispatch\_suspend(dispatchA);  
> 104.   
> 105. 则只会暂停dispatchA上原来的block的执行，dispatchB的block则不受影响。而如果暂停dispatchB的运行，则会暂停dispatchA的运行。

[view plain]: http://blog.csdn.net/crycheng/article/details/22214617#