多线程（三）GCD

一、GCD

GCD：Grand Central Dispatch，宏大的中央调度！！！是苹果为多核的并行运算提出的解决方案，会自动合理地利用更多的CPU内核（比如双核、四核）， GCD的底层依然是用线程实现，但是它会自动管理线程的生命周期（创建线程、调度任务、销毁线程），完全不需要我们管理，我们只需要告诉干什么就行。同时它使用的也是 C语言，不过由于使用了 Block（Swift里叫做闭包），使得使用起来更加方便，而且灵活。

二、GCD的两个概念：任务和队列

任务：即操作，就是一段代码，在 GCD 中就是一个 Block。任务有两种执行方式：同步执行和异步执行，他们之间的区别：是否会创建新的线程。
- 同步执行：只要是同步执行的任务，都会在当前线程执行，不会另开线程。
- 异步执行：只要是异步执行的任务，都会另开线程，在别的线程执行。

- 同步（sync）和异步（async）的主要区别在于会不会阻塞当前线程，直到 Block 中的任务执行完毕！
- 同步（sync）操作，会阻塞当前线程并等待 Block 中的任务执行完毕，然后当前线程才会继续往下运行。
- 异步（async）操作，当前线程会直接往下执行，它不会阻塞当前线程。

队列：用于存放任务。一共有两种队列，
- 串行队列：串行队列中的任务会根据队列的定义 FIFO 的执行，一个接一个的先进先出的进行执行。
- 并行队列：并行队列中的任务根据同步或异步有不同的执行方式。
  - 放到串行队列的任务，GCD 也会 FIFO的取出来，但不同的是，它取出来一个就会放到别的线程，然后再取出来一个又放到另一个的线程。这样由于取的动作很快，忽略不计，看起来，所有的任务都是一起执行的。不过需要注意，GCD 会根据系统资源控制并行的数量，所以如果任务很多，它并不会让所有任务同时执行。

三、创建队列

主队列：这是一个特殊的串行队列。它用于刷新 UI，任何需要刷新UI的工作都要在主队列执行，所以一般耗时的任务都要放到别的线程执行。
- dispatch_queue_t queue = dispatch_get_main_queue();
自己创建的队列：自己可以创建串行队列, 也可以创建并行队列。
- 它有两个参数，第一个参数是标识符，用于 DEBUG 的时候标识唯一的队列，可以为空。
- 第二个才是最重要的,用来表示创建的队列是串行的还是并行的，
  - 传入 DISPATCH_QUEUE_SERIAL 或 NULL 表示创建串行队列,通常用于同步访问特定的资源或数据。当你创建多个Serial queue时，虽然它们各自是同步执行的，但Serial queue与Serial queue之间是并发执行的。
  - 传入 DISPATCH_QUEUE_CONCURRENT 表示创建并行队列,可以并发地执行多个任务，但是执行完成的顺序是随机的。
- dispatch_queue_t queue = dispatch_queue_create("tk.bourne.testQueue", NULL);
全局并行队列：这应该是唯一一个并行队列，只要是并行任务一般都加入到这个队列。
- dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
- 优先级(第一个参数)：
  - #define DISPATCH_QUEUE_PRIORITY_HIGH 2 //优先级最高，在default,和low之前执行
    #define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认优先级，在low之前，在high之后
    #define DISPATCH_QUEUE_PRIORITY_LOW (-2) //在high和default后执行
    #define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN //提交到这个队列的任务会在high优先级的任务和已经提交到background队列的执行完后执行。

四、创建任务

同步任务：不会另开线程 (SYNC)
- dispatch_sync(, ^{
  
        //code here
  
        NSLog(@"%@", [NSThread currentThread]);
  
    });
异步任务：会另开线程 (ASYNC)
- dispatch_async(, ^{
  
        //code here
  
        NSLog(@"%@", [NSThread currentThread]);
  
    });
示例一：
- - (void)gcdTest{
      NSLog(@"之前 - %@ ", NSThread.currentThread);
      dispatch_sync(dispatch_get_main_queue(), ^{
          NSLog(@"sync - %@", NSThread.currentThread);
      });
      NSLog(@"之后 - %@", NSThread.currentThread);
  }
- // 只会打印第一句：之前 - {number = 1, name = main} ，然后主线程就卡死了
- 原因：同步任务会阻塞当前线程，然后把 Block 中的任务放到指定的队列中执行，只有等到 Block 中的任务完成后才会让当前线程继续往下运行。
- 打印完第一句后，dispatch_sync 立即阻塞当前的主线程，然后把 Block 中的任务放到 main_queue 中，可以 main_queue 中的任务会被取出来放到主线程中执行，但主线程这个时候已经被阻塞了，所以 Block 中的任务就不能完成，它不完成，dispatch_sync 就会一直阻塞主线程，这就是死锁现象。导致主线程一直卡死。
示例二：
- - (void)gcdTe1 {
      dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);
      NSLog(@“ 1 之前 - %@", NSThread.currentThread);
      dispatch_async(queue, ^{
          NSLog(@“ 2 同步之前 - %@", NSThread.currentThread);
          dispatch_sync(queue, ^{
             NSLog(@“ 3 同步 - %@", NSThread.currentThread);
          });
          NSLog(@“ 4 同步之后 - %@", NSThread.currentThread);
      });
      NSLog(@“ 5 之后 - %@", NSThread.currentThread);
  }
- 1，2，5会打印，3，4不会
- dispatch_async 异步执行，当前线程不会被阻塞，于是有了两条线程，一条当前线程继续往下打印出 1 , 另一条执行 Block 中的内容打印 2。因为这两条是并行的，所以打印的先后顺序无所谓。
  dispatch_sync同步执行，它所在的线程会被阻塞，一直等到 sync 里的任务执行完才会继续往下。于是 sync 就把自己 Block 中的任务放到 queue 中，可 queue 是一个串行队列，一次执行一个任务，所以 sync 的 Block 必须等到前一个任务执行完毕，但是 queue 正在执行的任务就是被 sync 阻塞了的那个。于是发生了死锁。所以 sync 所在的线程被卡死了。
队列组
- 可以将很多队列添加到一个组里，当这个组里所有的任务都执行完了，队列组会通过 dispatch_group_notify方法通知我们。
- 示例：
  - - (void)group1 {
        dispatch_group_t group = dispatch_group_create();
        dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
        //多次使用队列组的方法执行任务, 只有异步方法
        dispatch_group_async(group, queue, ^{
            for (NSInteger i = 0; i < 3; i++) {
                NSLog(@"group-01 - %@", [NSThread currentThread]);
            }
        });
    
        dispatch_group_async(group, dispatch_get_main_queue(), ^{
            for (NSInteger i = 0; i < 8; i++) {
                NSLog(@"group-02 - %@", [NSThread currentThread]);
            }
        });
    
        dispatch_group_async(group, queue, ^{
            for (NSInteger i = 0; i < 5; i++) {
                NSLog(@"group-03 - %@", [NSThread currentThread]);
            }
        });
        //都完成后会自动通知
        dispatch_group_notify(group, dispatch_get_main_queue(), ^{
            NSLog(@"完成 - %@", [NSThread currentThread]);
        });
    }

五、单例模式

@interface Tool : NSObject
+ (instancetype)sharedTool;
@end
@implementation Tool
static id _instance;
+ (instancetype)sharedTool {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        _instance = [[Tool alloc] init];
    });
    return _instance;
}
@end

六、延迟执行

dispatch_after：延迟一段时间把一项任务提交到队列中执行，返回之后就不能取消
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ //code });
- delayInSeconds 延迟的时间
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"---->(∩_∩)O哈哈~”); //延迟5秒
});
可以对它封装一下
- - (void)myGcdAfterTime:(double)time codeBlock:(void (^)())codeBlock{
  dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(time * NSEC_PER_SEC)), dispatch_get_main_queue(), codeBlock);
  }
- 使用：[selfmyGcdAfterTime:5.0codeBlock:^{
  NSLog(@"---->O(∩_∩)O哈哈~");
  }];

七、其他用法

屏障
dispatch_barrier_async 是在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行
- 这个方法重点是你传入的 queue，当你传入的 queue 是通过 DISPATCH_QUEUE_CONCURRENT 参数自己创建的 queue 时，这个方法会阻塞这个 queue（注意是阻塞 queue ，而不是阻塞当前线程），一直等到这个 queue 中排在它前面的任务都执行完成后才会开始执行自己，自己执行完毕后，才会取消阻塞，使这个 queue 中排在它后面的任务继续执行。
- 如果你传入的是其他的 queue, 那么它就和 dispatch_async 一样了
- 示例：
  - - (void)gcdBarrier {
        dispatch_queue_t queue = dispatch_queue_create("gcdtest.wwl", DISPATCH_QUEUE_CONCURRENT);
        dispatch_async(queue, ^{
            [NSThread sleepForTimeInterval:2];
            NSLog(@"---> 1 ");
        });
        dispatch_async(queue, ^{
            [NSThread sleepForTimeInterval:4];
            NSLog(@"---> 2 ");
        });
        dispatch_barrier_async(queue, ^{
            NSLog(@"---> 3 ");
            [NSThread sleepForTimeInterval:4];
    
        });
        dispatch_async(queue, ^{
            [NSThread sleepForTimeInterval:1];
            NSLog(@"---> 4 ");
        });
    }
  - 注意打印时间
  - 13:38:15.526 ---> 1
    13:38:17.526 ---> 2
    13:38:17.527 ---> 3
    13:38:22.539 ---> 4
dispatch_barrier_sync
- 这个方法的使用和上一个一样，传入自定义的并发队列（DISPATCH_QUEUE_CONCURRENT），它和上一个方法一样的阻塞 queue，不同的是这个方法还会阻塞当前线程。
- 如果你传入的是其他的 queue, 那么它就和 dispatch_sync 一样了。

dispatch_apply
- 把一项任务提交到队列中多次执行，具体是并行执行还是串行执行由队列本身决定.注意，dispatch_apply不会立刻返回，在执行完毕后才会返回，是同步的调用。
dispatch_apply(size_t iterations, dispatch_queue_t queue, ^(size_t) { //code });
- size_t iterations：代码执行次数
- dispatch_queue_t queue：传入的队列
- size_t：代码当前的执行次数，
示例：
- - (void)gcdApply {
      dispatch_apply(5, dispatch_get_global_queue(0, DISPATCH_QUEUE_PRIORITY_DEFAULT), ^(size_t index) {
     NSLog(@"----> %ld %@",index, [NSThread currentThread]);
      });
  }
- ----> 0 <NSThread: 0x16669b20>{number = 1, name = main}
  ----> 1 <NSThread: 0x16587ed0>{number = 2, name = (null)}
  ----> 3 <NSThread: 0x16587ed0>{number = 2, name = (null)}
  ----> 4 <NSThread: 0x16587ed0>{number = 2, name = (null)}
  ----> 2 <NSThread: 0x16669b20>{number = 1, name = main}
- 因为传入的是全局队列，是并行的，所以会开线程，打印的顺序不确定。
- 换成串行队列会循序打印,不开线程
- dispatch_queue_t queue = dispatch_queue_create("gcdtest.wwl", DISPATCH_QUEUE_SERIAL);
      dispatch_apply(5, queue, ^(size_t index) {
          NSLog(@"----> %ld %@",index,[NSThread currentThread]);
      });
从其他线程回到主线程
- dispatch_async(dispatch_get_main_queue(), ^{
  //注意是异步
  });

下载图片示例：
- - (void)downloadImages {
      dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  
      // 异步下载图片
      dispatch_async(queue, ^{
          // 创建一个组
          dispatch_group_t group = dispatch_group_create();
  
          __blockUIImage *image1 = nil;
          __blockUIImage *image2 = nil;
  
          // 关联一个任务到group
          dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
              // 下载第一张图片
              NSString *url1 = @"http://car0.autoimg.cn/upload/spec/9579/u_20120110174805627264.jpg";
              image1 = [selfimageWithURLString:url1];
          });
  
          // 关联一个任务到group
          dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
              // 下载第一张图片
              NSString *url2 = @"http://hiphotos.baidu.com/lvpics/pic/item/3a86813d1fa41768bba16746.jpg";
              image2 = [selfimageWithURLString:url2];
          });
  
          // 等待组中的任务执行完毕,回到主线程执行block回调
          dispatch_group_notify(group, dispatch_get_main_queue(), ^{
              self.imageView1.image = image1;
              self.imageView2.image = image2;
          });
      });
  }
  
  - (UIImage *)imageWithURLString:(NSString *)urlString {
      NSURL *url = [NSURLURLWithString:urlString];
      NSData *data = [NSDatadataWithContentsOfURL:url];
      return [[UIImagealloc] initWithData:data];
  }

参考博客