GCD总结0

GCD
全称：Grand Central Dispatch
简介：GCD是对多线程、多核开发较完整的封装。在使用GCD的时候，系统会自动根据CPU使用情况进行调度，所以GCD是
一个简单易用，但是效果很好地多线程多核开发工具。
要注意的地方：
1、慎用fork()函数（不是十分清楚流程不要用）
2、GCD是C语言级别的API，所以不会抓到异常，在一个提交到GCD的任务完成之前，应当处理完异常。


教程一
教程一涵盖了
1、GCD全局队列的四个优先级
2、几种本文使用到的GCD类型
3、dispatch_async/dispatch_async_f
4、dispatch_sync/dispatch_sync_f


一、概念与类型
对于GCD来说，所有的执行都放到队列中(queue)，队列的特点是FIFO（先提交的先执行）。
GCD的队列分为几种，主队列（main）,全局队列(global),用户创建队列(create)
对于全局队列，默认有四个，分为四个优先级

[cpp] view plaincopy

1. #define DISPATCH_QUEUE_PRIORITY_HIGH         2 

2. #define DISPATCH_QUEUE_PRIORITY_DEFAULT      0 

3. #define DISPATCH_QUEUE_PRIORITY_LOW          (-2) 

4. #define DISPATCH_QUEUE_PRIORITY_BACKGROUND   INT16_MIN 

DISPATCH_QUEUE_PRIORITY_HIGH:优先级最高，在default,和low之前执行
DISPATCH_QUEUE_PRIORITY_DEFAULT默认优先级，在low之前，在high之后
DISPATCH_QUEUE_PRIORITY_LOW在high和default后执行
DISPATCH_QUEUE_PRIORITY_BACKGROUND:提交到这个队列的任务会在high优先级的任务和已经提交到background队列的执行完后执行。官方文档：(the queue is scheduled for execution after all high priority queues have been scheduled and the system runs items on a thread whose priority is set for background status.)


几种使用到的类型

[cpp] view plaincopy

1. typealias dispatch_queue_t = NSObject//轻量级的用来描述执行任务的队列 

2. typealias dispatch_block_t = () -> Void//队列执行的闭包(Objective C中的block) 

几个概念
异步提交的任务立刻返回，在后台队列中执行
同步提交的任务在执行完成后才会返回
并行执行（全局队列）提交到一个队列的任务，比如提交了任务1和任务2，在任务1开始执行，并且没有执行完毕时候，任务2就可以开始执行。
串行执行（用户创建队列） 提交到一个队列中的任务，比如提交了任务1和任务2，只有任务1结束后，任务2才可执行

注意：提交到队列中的任务是串行执行，还是并行执行由队列本身决定。

二、示例详解

[plain] view plaincopy

1. func dispatch_async(_ queue: dispatch_queue_t!, 

2.                   _ block: dispatch_block_t!) 

参数：
queue 提交到的队列，队列的类型决定了是串行还是并行执行队列中的任务
block 执行的闭包

[plain] view plaincopy

1. func dispatch_async_f(_ queue: dispatch_queue_t!, 

2.                     _ context: UnsafeMutablePointer<Void>, 

3.                     _ work: dispatch_function_t) 

参数
queue 提交到的队列，队列的类型决定了是串行还是并行执行队列中的任务
context 传递给work的参数

work 执行的函数(C语言函数)

dispatch_sync 和 dispatch_sync的参数和上述对应一致，所以不再列出

总得来说带有后缀_f(比如dispatch_sync_f，dispatch_after_f)就是提交给队列一个C语言函数，因为极少用到这种形式，这里仅给出一个简单例子，后面的涉及到_f的都略过。

1、dispatch_async/dispatch_sync
功能：提交到队列中异步/同步执行
本示例：下载一张图片，图片下载完毕后通知UI改变
注意：要改变UI必须在主队列上执行
这里用到了一个获取全局队列的函数

[plain] view plaincopy

1. func dispatch_get_global_queue(_ identifier: Int, 

2.                              _ flags: UInt) -> dispatch_queue_t! 

这个函数的第一个参数是队列的优先级，第二个参数尚没有意义，直接写0就可以了。

创建一个基于单页面的Swift工程，然后在ViewController.swift中，

[plain] view plaincopy

1. class ViewController: UIViewController{   

2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))   

3.     override func viewDidLoad(){   

4.         super.viewDidLoad()   

5.         imageview.contentMode = UIViewContentMode.ScaleAspectFit   

6.         self.view.addSubview(imageview)   

7.         let url = "http://f.hiphotos.baidu.com/image/pic/item/e1fe9925bc315c60191d32308fb1cb1348547760.jpg"   

8.         let imageURL = NSURL(string:url)    

9.     var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0) 

10.     dispatch_async(globalQueueDefault){ 

11.         var imageData = NSData(contentsOfURL:imageURL!) 

12.         var image = UIImage(data:imageData!) 

13.         if let successfulImage = image{ 

14.             sleep(2) 

15.             dispatch_async(dispatch_get_main_queue()){ 

16.                 self.imageview.image = successfulImage 

17.             } 

18.         } 

19.     } 

20.     }   

21.     override func didReceiveMemoryWarning(){   

22.         super.didReceiveMemoryWarning()   

23.     }   

24. }   

执行，观察下效果：view立刻载入，然后过一段时间，图片下载完了，UI改变
然后，我们观察dispatch_sync
只需要修改这一行即可

[plain] view plaincopy

1. dispatch_sync(globalQueueDefault,0){ 

执行，观察下效果：view载入很慢，但是在载入的时候，图片下载完了。UI已经改变。可以打在这一行打断点，会发现异步执行会立刻返回，同步执行会等待执行结束后返回。
所以，当我们有一件非常耗时的事情，放到后台队列中去做，等做完了通知UI改变，是不会阻塞UI，降低用户体验的。


2、dispatch_async_f/dispatch_sync_f
简单的实例，把一个C函数提交给队列
首先，建立一个基于单页面的swift工程,命名为testForCSDN，然后再新建一个C语言文件，命名为hwcText->点击包括头文件->点击包含Bridging-Header.h
这样，工程里多了三个文件
hwcTest.c
hwcTest.h
testForCSDN-Bridging-Header.h
附上完整的代码
testForCSDN-Bridging-Header.h

[cpp] view plaincopy

1. #import "hwcTest.h" 

hwcTest.h

[cpp] view plaincopy

1. #include <stdio.h> 

2. #include <unistd.h> 

3. typedefvoid (*hwcTestForGCD)(void*); 

4. hwcTestForGCD getFuncPointer(); 

hwcTest.c

[cpp] view plaincopy

1. #include "hwcTest.h" 

2. void realFunction(void *input){ 

3.    for(int i = 0;i < 5;i++){ 

4.         printf("%d\n",i); 

5.         sleep(1); 

6.     } 

7. } 

8. hwcTestForGCD getFuncPointer(){ 

9.    return realFunction; 

10. } 

ViewController.swift

[plain] view plaincopy

1. class ViewController: UIViewController{   

2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))   

3.     override func viewDidLoad(){   

4.         super.viewDidLoad()   

5.         var globalQueueDefault = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0) 

6.     dispatch_async_f(globalQueueDefault,nil,getFuncPointer()) 

7.     println("dispatch is over") 

8.     }   

9.     override func didReceiveMemoryWarning(){   

10.         super.didReceiveMemoryWarning()   

11.     }   

12. }  

然后执行，会发现输出

[plain] view plaincopy

1. 0 

2. dispatch is over 

3. 1 

4. 2 

5. 3 

6. 4 

然后，我们同样改成dispatch_sync后执行，发现输出

[plain] view plaincopy

1. 0 

2. 1 

3. 2 

4. 3 

5. 4 

6. 5 

7. dispatch is over 

这里更能体会到了，什么是同步，什么是异步了吧。


三、理解下并行队列和串行队列
使用一或者二中的工程都可以，修改ViewController.swft中的代码就可以
这里用到了一个函数

[plain] view plaincopy

1. func dispatch_queue_create(_ label: UnsafePointer<Int8>, 

2.                          _ attr: dispatch_queue_attr_t!) -> dispatch_queue_t! 

参数
labelString类型的队列标示符，通常取做com.companyname.productname.functionname
attr 两种类型。DISPATCH_QUEUE_SERIAL创建一个顺序执行队列， DISPATCH_QUEUE_CONCURRENT创建同时执行队列


ViewController的完整代码，这里提交两个任务，通过输出来判断是并行队列，还是串行队列

[plain] view plaincopy

1. class ViewController: UIViewController{   

2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))   

3.     override func viewDidLoad(){   

4.         super.viewDidLoad()  

5.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){ 

6.         for var i = 0;i < 5;i++ { 

7.             NSLog("First task:%d",i) 

8.             sleep(1) 

9.         } 

10.     } 

11.     dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0)){ 

12.         for var j = 0;j < 5;j++ { 

13.             NSLog("Second task:%d",j) 

14.             sleep(1) 

15.         } 

16.     } 

17.     println("dispatch is over") 

18.     }   

19.     override func didReceiveMemoryWarning(){   

20.         super.didReceiveMemoryWarning()   

21.     }   

22. }  

这里执行输出为：

[plain] view plaincopy

1. First task:0 

2. Second task:0 

3. First task:1 

4. Second task:1 

5. First task:2 

6. Second task:2 

7. First task:3 

8. Second task:3 

9. First task:4 

10. Second task:4 

这段代码执行时间4.03s

然后，我们使用串行执行的队列

[plain] view plaincopy

1. class ViewController: UIViewController{   

2.     var imageview = UIImageView(frame: CGRectMake(40,40,200,200))   

3.     override func viewDidLoad(){   

4.         super.viewDidLoad() 

5.     var serialQueue =  dispatch_queue_create(label:  

6.  

7.  

8. "com.test.helloHwc",attr:DISPATCH_QUEUE_SERIAL) 

9.     dispatch_async(serialQueue){ 

10.         for var i = 0;i < 5;i++ { 

11.             NSLog("First task:%d",i) 

12.             sleep(1) 

13.         } 

14.     } 

15.     dispatch_async(serialQueue){ 

16.         for var j = 0;j < 5;j++ { 

17.             NSLog("Second task:%d",j) 

18.                         sleep(1) 

19.         } 

20.     } 

21.     println("dispatch is over") 

22.     }   

23.     override func didReceiveMemoryWarning(){   

24.         super.didReceiveMemoryWarning()   

25.     }   

26. }  

这里输出为

[plain] view plaincopy

1. First task:0 

2. First task:1 

3. First task:2 

4. First task:3 

5. First task:4 

6. Second task:0 

7. Second task:1 

8. Second task:2 

9. Second task:3 

10. Second task:4 

这段代码执行时间8.06秒

看出来并行和串行执行的差别了吧。

所以，记住一点，把过程不相关的任务，提交到并行的队列中会显著提高效率