GCD是Grand Central Dispatch的简称，它是基于C语言的。相信读者已经看过很多大神们对GCD深入浅出的分析，这也是老生常谈的一个多线程的实现方式了，所以我也就不再啰嗦其理论。但是到底有多少方法是我们日常编程中常用的？又有多少是你不知道的？今天，我就来例举一些GCD的方法，绝对让你看一眼就会正确得使用。
与其说CGD是线程管理，不如说是队列管理，那么我们先来介绍一下GCD中常用的队列：

• Concurrent Diapatch Queue 并发队列
  并发队列创建有限的几个线程并发执行，关键字DISPATCH_QUEUE_CONCURRENT
  dispatch_queue_t currentDispatchQueue = dispatch_queue_create("com.test.queue", DISPATCH_QUEUE_CONCURRENT);
  dispatch_async(currentDispatchQueue, ^{
  NSLog(@"1");
  });
  dispatch_async(currentDispatchQueue, ^{
  sleep(2);
  NSLog(@"2");
  });
  dispatch_async(currentDispatchQueue, ^{
  sleep(1);
  NSLog(@"3");
  });
• Serial Diapatch Queue 串行队列
  当任务相互依赖,串行队列是在一个线程上执行的，具有先后顺序的，关键字DISPATCH_QUEUE_SERIAL
  dispatch_queue_t serialDiapastchQueue = dispatch_queue_create("com.test.queue", DISPATCH_QUEUE_SERIAL);
  dispatch_async(serialDiapastchQueue, ^{
  NSLog(@"1");
  });
  dispatch_async(serialDiapastchQueue, ^{
  sleep(2);
  NSLog(@"2");
  });
  dispatch_async(serialDiapastchQueue, ^{
  sleep(1);
  NSLog(@"3");
  });
• Global Queue & Main Queue系统为我们创建的队列
  • Global Queue其实就是系统创建的Concurrent Diapatch Queue
  • Main Queue 其实就是系统创建的位于主线程的Serial Diapatch Queue

通常情况我们会把这2个队列放在一起使用，也是我们最常用的开异步线程-执行异步任务-回主线程的一种方式：

 dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       NSLog(@"异步线程");
    dispatch_async(dispatch_get_main_queue(), ^{
        NSLog(@"异步主线程");
    });
});

异步主线程
在日常工作中，除了在其他线程返回主线程的时候需要用这个方法，还有一些时候我们在主线程中直接调用异步主线程，这是利用dispatch_async的特性：block中的任务会放在主线程本次runloop之后返回。这样，有些存在先后顺序的问题就可以得到解决了。
dispatch_get_global_queue存在优先级，他一共有4个优先级：

#define DISPATCH_QUEUE_PRIORITY_HIGH 2 最高
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 其次（默认）
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) 次之
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN 最后

• dispatch_set_target_queue 管理自己创建的队列执行优先级

刚刚我们说了系统的Global Queue是可以指定优先级的，那我们如何给自己创建的队列执行优先级呢？这里我们就可以用到dispatch_set_target_queue这个方法：

  dispatch_queue_t serialDispatchQueue = dispatch_queue_create("com.test.queue", NULL);
  dispatch_queue_t dispatchGetGloabalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
  // dispatch_set_target_queue 的第一个参数是queue 第二个参数是参照物  指的就是第一个queue的优先级跟参照物的优先级一样
  dispatch_set_target_queue(serialDispatchQueue, dispatchGetGloabalQueue);
  dispatch_async(serialDispatchQueue, ^{
      NSLog(@"我优先级低，先让让");
  });
  dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
      NSLog(@"我优先级高，我先block");
  });

我把自己创建的队列塞到了系统提供的global_queue队列中，我们可以理解为：我们自己创建的queue其实是位于global_queue中执行,所以改变global_queue的优先级，也就改变了我们自己所创建的queue的优先级。所以我们常用这种方式来管理子队列。

• dispatch_after 延时操作

这个是最常用的，用来延迟执行的GCD方法，因为在主线程中我们不能用sleep来延迟方法的调用，所以用它是最合适的，我们做一个简单的例子：

  double delayInSeconds = 2.0;
  dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(delayInSeconds*NSEC_PER_SEC));
  dispatch_after(popTime, dispatch_get_main_queue(), ^{
      NSLog(@"演示操作，主线程刷新");
  });

• dispatch_group 分组管理队列 监听队列任务是否完成

当我们需要监听一个并发队列中，所有任务都完成了，就可以用到这个group，因为并发队列你并不知道哪一个是最后执行的，所以以单独一个任务是无法监听到这个点的，如果把这些单任务都放到同一个group，那么，我们就能通过dispatch_group_notify方法知道什么时候这些任务全部执行完成了。

  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  dispatch_group_t group = dispatch_group_create();
  dispatch_group_async(group, queue, ^{
      NSLog(@"0");
  });
  dispatch_group_async(group, queue, ^{
      NSLog(@"1");
  });
  dispatch_group_async(group, queue, ^{
      NSLog(@"2");
  });
  dispatch_group_notify(group, dispatch_get_main_queue(), ^{
      NSLog(@"执行over");
  });

在例子中，我把3个log分别放在并发队列中，通过把这个并发队列任务统一加入group中，group每次runloop的时候都会调用一个方法dispatch_group_wait(group, DISPATCH_TIME_NOW)，用来检查group中的任务是否已经完成，如果已经完成了，那么会执行dispatch_group_notify的block。

• dispatch_barrier_async 线程锁

此方法的作用是在并发队列中，完成在它之前提交到队列中的任务后打断，单独执行其block，并在执行完成之后才能继续执行在他之后提交到队列中的任务：

  dispatch_queue_t concurrentDispatchQueue =   dispatch_queue_create("com.test.barrier", DISPATCH_QUEUE_CONCURRENT);
  dispatch_async(concurrentDispatchQueue, ^{
      NSLog(@"0");
  });
  dispatch_async(concurrentDispatchQueue, ^{
      NSLog(@"1");
  });
  dispatch_async(concurrentDispatchQueue, ^{
      NSLog(@"2");
  });
  dispatch_barrier_async(concurrentDispatchQueue, ^{
      sleep(2);
      NSLog(@"3");
  });
  dispatch_async(concurrentDispatchQueue, ^{
      NSLog(@"4");
  });
  dispatch_async(concurrentDispatchQueue, ^{
      NSLog(@"5");
  });
  dispatch_async(concurrentDispatchQueue, ^{
      NSLog(@"6");
  });

线程锁 在多个线程同时操作一个对象的时候，读可以放在并发进行，当写的时候，我们就可以用dispatch_barrier_async方法，效果杠杠的。

• dispatch_sync 同步队列

dispatch_sync 会在当前线程执行队列，并且阻塞当前线程中之后运行的代码，所以，同步线程非常有可能导致死锁现象，我们这边就举一个死锁的例子，直接在主线程调用以下代码：

  dispatch_sync(dispatch_get_main_queue(), ^{
      NSLog(@"有没有同步主线程?");
  });

根据FIFO（先进先出）的原则，block里面的代码应该在主线程此次runloop后执行，但是由于他是同步队列，所有他之后的代码会等待其执行完成后才能继续执行，2者相互等待，所以就出现了死锁。

• dispatch_apply 遍历数组

这个方法虽然会开启多个线程来遍历这个数组，但是在遍历完成之前会阻塞主线程。

  NSArray *array = @[@"1",@"2",@"3",@"4",@"5",@"6",@"7",@"8",@"9",@"10"];
  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  dispatch_apply([array count], queue, ^(size_t index) {
      NSLog(@"%zu====%@",index,array[index]);
  });
  NSLog(@"阻塞");

• dispatch_suspend & dispatch_resume 队列的挂起和恢复
  dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
  dispatch_async(queue, ^{
  for (int i = 0; i<100; i++) {
  NSLog(@"%i",i);
  if (i==50) {
  NSLog(@"---------------------------");
  dispatch_suspend(queue);
  sleep(3);
  dispatch_async(dispatch_get_main_queue(), ^{
  dispatch_resume(queue);
  });
  }
  }
  });

• Semaphore 信号量管理并发数

我们可以通过设置信号量的大小，来解决并发过多导致资源吃紧的情况，以单核CPU做并发为例，一个CPU永远只能干一件事情，那如何同时处理多个事件呢，聪明的内核工程师让CPU干第一件事情，一定时间后停下来，存取进度，干第二件事情以此类推，所以如果开启非常多的线程，单核CPU会变得非常吃力，即使多核CPU，核心数也是有限的，所以合理分配线程，变得至关重要，那么如何发挥多核CPU的性能呢？如果让一个核心模拟传很多线程，经常干一半放下干另一件事情，那效率也会变低，所以我们要合理安排，将单一任务或者一组相关任务并发至全局队列中运算或者将多个不相关的任务或者关联不紧密的任务并发至用户队列中运算，所以用好信号量，合理分配CPU资源，程序也能得到优化，当日常使用中，信号量也许我们只起到了一个计数的作用，真的有点大材小用。

  dispatch_semaphore_t semaphore = dispatch_semaphore_create(2);//为了让一次输出10个，初始信号量为10
  dispatch_queue_t queue =   dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  for (int i = 0; i < 10; i++) {
    dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
    NSLog(@"信号量-1");
    dispatch_async(queue, ^{
        NSLog(@"%i\n",i);
        sleep(5);
        NSLog(@"信号量+1");
        dispatch_semaphore_signal(semaphore);//由于这里只是log,所以处理速度非常快，我就模拟2秒后信号量+1;
    });
  }

• dispatch_once 一般实用于单例
  static NSString *instance;
  static dispatch_once_t onceToken;
  dispatch_once(&onceToken, ^{
  instance = [[NSString alloc]init];
  });

• dispatch_source_set_event_handler 计时器
  __block int index = 0;
  dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
  dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 1.0 * NSEC_PER_SEC, 0.0 * NSEC_PER_SEC);
  dispatch_source_set_event_handler(timer, ^{
  NSLog(@"------ index == %d -------",index);
  index++;
  if (index > 20) {
  dispatch_source_cancel(timer);
  }
  });
  dispatch_source_set_cancel_handler(timer, ^{
  NSLog(@"取消🐶🐶🐶🐶🐶🐶");
  });
  dispatch_resume(timer);