初学iOS----多线程（二：GCD详解）

GCD.png

GCD（Grand Central Dispatch）特点

纯C语言编写，所以在使用的时候，使用的是函数而不是方法（提供了非常多强大的函数）。
GCD是苹果公司为多核的并行运算提出的解决方案
GCD会自动利用更多的CPU内核（比如双核、四核）
GVD会自动管理线程的生命周期线程（创建线程、调度任务、销毁线程）

核心概念

任务：执行什么操作用block来封装任务
执行任务的函数有2个
用同步的方式执行任务：不具备开启新线程的能力:
dispatch_sync...
用异步的方式执行任务：具备开启新线程的能力:
dispatch_async...
队列：用来存放任务
GCD的队列可以分为两大类型:串行队列和并发队列
串行队列
让任务一个接一个执行（一个完成，执行下一个）
并发队列
1.可以让多个任务并发（同时）执行（自动开启了多个线程，同时执行任务）
2.并发功能只能在异步函数下才会有效
并发和串行，决定了任务的执行方式

到这里有4个术语：同步，异步，并发，串行

同步和异步主要影响：能不能开启新的线程
同步：在当前线程中执行任务，不具备开启新线程的能力
异步：在新的线程中执行任务，具备开启新线程的能力

并发和串行主要影响：任务的执行方式
并发：多个任务同时执行
串行：多个任务挨个执行（一个任务执行完毕后，再去执行下一个任务）

使用GCD的两个步骤

1.定制任务：确定需要做什么事情
2.将任务添加到队列中：
1> GCD会自动将队列中的任务取出，放到对应的线程中。
2>而任务的取出，遵循队列的先进先出（FIFO）原则。

GCD中获得串行队列的2种方式：（这里说的都是ARC的情况，非ARC情况不再叙述）

#1.使用dispatch_queue_create函数创建队列
dispatch_queue_t queue =dispatch_queue_create("queue",0);
//或者
dispatch_queue_t queue = dispatch_queue_create(DISPATCH_QUEUE_SERIAL, 0);
//第一个参数：队列名称，可以使用系统提供的宏或0
//第二个参数：队列属性，它是系统保留字段，写0即可
//创建串行队列时，如果使用系统提供的宏，那么第一个参数和第二个参数是可以互换位置的。即
dispatch_queue_t queue = dispatch_queue_create(0, DISPATCH_QUEUE_SERIAL);
#2.使用主队列
//1.主队列是GCD自带的一种特殊的串行队列
//2.放在主队列中任务，都会放到主线程中执行（可用于线程通信，回到主队列）
dispatch_queue_t queue = dispatch_get_main_queue();
#然后将任务添加到队列中
//串行队列 + 同步任务：（没有开启子线程）
dispatch_sync(queue, ^{
        NSLog(@"串行 + 同步 %@",[NSThread currentThread]);
    });
//串行队列 + 异步任务：只开一个线程
 dispatch_async(queue2, ^{
        NSLog(@"串行 + 异步 %@",[NSThread currentThread]);
    });

GCD创建并发队列的两种方式：

#1.系统方法创建并发队列（全局队列）
/*
     dispatch_get_global_queue ( long identifier: 优先级（有四个）
                                 unsigned long flags:系统保留关键字，暂时写0 )
     */
 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
/* 全局并发队列的优先级
DISPATCH_QUEUE_PRIORITY_HIGH 2  // 高
DISPATCH_QUEUE_PRIORITY_DEFAULT 0  // 默认（中）
DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台
一般都用默认的
*/
#2.自己创建一个并发队列
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
//注意，这里两个参数的位置不能互换
#然后，将任务添加到队列中
//并发 + 同步：不开启子线程
    dispatch_sync(queue, ^{
        NSLog(@"并发 + 同步 %@",[NSThread currentThread]);
    });
//并发 + 异步：可以开启子线程（一般同时开启多条线程）
    dispatch_async(queueS, ^{
        NSLog(@"并发 + 异步 %@",[NSThread currentThread]);
    });

看下面这个列表可能会更直观一点

	全局并发队列	手动创建串行队列	主队列
同步(sync)	没有开启新线程串行执行任务	没有开启新线程串行执行任务	没有开启新线程串行执行任务
异步(async)	有开启新线程并发执行任务（最常用）	有开启新线程串行执行任务	没有开启新线程串行执行任务

这个列表是参照网上的图写的，可以简单明了的看出串行、并发和同步、异步之间的相互关系而又不至于弄混

线程间通信

上面几种方式都理解后，就可以进行一些简单的线程间的通信，线程间通信其实就是一个线程和另一个线程的数据传输，比如下载图片，回到主线程刷新，这里又一个最最常用的方法：

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
 //执行耗时的异步操作...
 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
 //回到主线程，执行刷新UI操作
      });
 });

简单的通信大致都是按照这个思路走的。

延时执行

意思就是让程序几秒后再执行
首先有一点注意，就是延时执行不要用sleep方法，使用这个方法的话放在主线程卡主线程，放在子线程卡子线程
除了sleep外，还有两种延时执行的方法：

调用NSObject的方法

     [self performSelector:@selector(download:) withObject:@"nil" afterDelay:3.0];
*使用GCD函数
 dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"3秒延时执行");
 });

线程锁死

线程锁死的情况发生在串行队列中，先看下面一段代码：

 //调用主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    //在串行队列中创建异步任务（开辟新线程，执行任务）
    dispatch_async(queue, ^{
        NSLog(@"我是查询操作1 %@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"我是查询操作2 %@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"我是查询操作3 %@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"我是查询操作4 %@",[NSThread currentThread]);
    });
    
    dispatch_async(queue, ^{
        NSLog(@"我是查询操作5 %@",[NSThread currentThread]);
    });
    NSLog(@"123");

最后打印的123相当于调用了主线程
打印结果：

GCD.png

可以看出，使用异步函数执行任务时，它可以先不执行，等主线程的任务执行完毕后，再去执行。再看同步函数：

//调用主队列
    dispatch_queue_t queue = dispatch_get_main_queue();
    
    //在串行队列中创建异步任务（开辟新线程，执行任务）
    dispatch_sync(queue, ^{
        NSLog(@"我是查询操作1 %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"我是查询操作2 %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"我是查询操作3 %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"我是查询操作4 %@",[NSThread currentThread]);
    });
    
    dispatch_sync(queue, ^{
        NSLog(@"我是查询操作5 %@",[NSThread currentThread]);
    });
    NSLog(@"123");

然后就没有然后了，这里线程就锁死了，因为当使用同步函数执行任务时，同样，需要等主线程任务执行完毕后再执行，但是，它本身就在主线程，而且要当前任务执行完，才能执行下一个，不能像异步函数那样先不执行，这样，就陷入死循环，就造成了线程的锁死，这里的打印结果是出不来的。

队列组的使用

队列的创建使用这个函数：

   //创建一个分组
    dispatch_group_t group = dispatch_group_create();
    //创建一个队列
    dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);
    //向分组中添加一个任务
    dispatch_group_async(group, queue, ^{
        NSLog(@"啦啦啦");
    });

队列组有一个特点，就是等所有group里的任务执行完毕后，会调用这个方法：

  dispatch_group_notify(group, queue, ^{
        NSLog(@"最后调用");
    });

关于队列组的使用，可以举一个简单的例子，例如合并图片，对一张图片加水印
所有的代码如下：

- (void)touchesBegan:(NSSet *)touches withEvent:(UIEvent *)event
{
    // 1.队列组
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
    // 2.下载图片1
    __block UIImage *image1 = nil;
    dispatch_group_async(group, queue, ^{
        NSURL *url1 = [NSURL URLWithString:@"http://img.ekoooo.com/userup/0902/0H00055Y09.jpg"];
        NSData *data1 = [NSData dataWithContentsOfURL:url1];
        image1 = [UIImage imageWithData:data1];
    });
    
    // 3.下载图片2
    __block UIImage *image2 = nil;
    dispatch_group_async(group, queue, ^{
        NSURL *url2 = [NSURL URLWithString:@"https://ss0.bdstatic.com/5aV1bjqh_Q23odCf/static/superman/img/logo/bd_logo1_31bdc765.png"];
        NSData *data2 = [NSData dataWithContentsOfURL:url2];
        image2 = [UIImage imageWithData:data2];
    });
    
    // 4.合并图片 (保证执行完组里面的所有任务之后，再执行notify函数里面的block)
    dispatch_group_notify(group, queue, ^{
        // 开启一个位图上下文
        UIGraphicsBeginImageContextWithOptions(image1.size, NO, 0.0);
        
        // 绘制第1张图片
        CGFloat image1W = image1.size.width;
        CGFloat image1H = image1.size.height;
        [image1 drawInRect:CGRectMake(0, 0, image1W, image1H)];
        
        // 绘制第2张图片
        CGFloat image2W = image2.size.width * 0.5;
        CGFloat image2H = image2.size.height * 0.5;
        CGFloat image2Y = image1H - image2H;
        [image2 drawInRect:CGRectMake(150, image2Y - 20 , image2W, image2H )];
        
        // 得到上下文中的图片
        UIImage *fullImage = UIGraphicsGetImageFromCurrentImageContext();
        
        // 结束上下文
        UIGraphicsEndImageContext();
        
        // 5.回到主线程显示图片
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = fullImage;
        });
    });
}

用到了Quartz2D的一些东西，另外因为有网络请求，记得在info.plist下
添加 NSAppTransportSecurity 类型 Dictionary 下
添加NSAllowsArbitraryLoads 类型 Boolean ,值设为 YES
运行效果有点丑，不展示了，水印嘛，想象一下就好，都知道的

	全局并发队列	手动创建串行队列	主队列
同步(sync)	没有开启新线程串行执行任务	没有开启新线程串行执行任务	没有开启新线程串行执行任务
异步(async)	有开启新线程并发执行任务（最常用）	有开启新线程串行执行任务	没有开启新线程串行执行任务