在软件开发中使用多线程可以大大地提高用户体验，提高效率。Grand Central Dispatch（CGD）则是C语言的一套多线程开发框架，相比NSThread和NSOperation，GCD更加高效，并且线程由系统管理，会自动运行多核运算。因为这些优势，GCD是Apple推荐给开发者使用的首选多线程解决方案。

1、GCD的调度机制

GCD框架中一个很重要的概念是调度队列，我们对线程的操作实际上是由调度队列完成的。我们只需要将要执行的任务添加到合适的队列中即可。在GCD框架中，有如下三种类型的调度队列。

1.1主队列

其中的任务在主线程中执行，因为其会阻塞主线程，所以是一个串行的队列。可以通过下面的方法得到：

dispatch_get_main_queue();

1.2全局并行队列

队列中任务的执行严格按照先进先出的模式进行。如果是串行的队列，则当一个任务结束后，才会开启另一个任务，如果是并行队列，则任务的开启顺序和添加顺序是一致的。系统为iOS应用自动创建了4个全局共享的并发队列。使用下面的函数获得：

dispatch_get_global_queue(<#long identifier#>, <#unsigned long flags#>);

上面函数的第一个参数是这个队列的ID，系统的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//后台的全局队列，优先级别最低

这个函数的第二个参数是一个预留参数，我们可以传NULL.

1.3自定义队列

上面的两种队列都是系统为我们创建好的，我们只需要获取到他们，添加任务即可。当然我们也可以创建自己的队列，包含串行和并行的。使用如下方法来创建：

dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);

其中第一个参数是这个队列的名字，第二个参数决定创建的是串行还是并行队列。填写DISPATCH_QUEUE_SERIAL或NULL创建串行队列，填写DISPATCH_QUEUE_CONCURRENT创建并行队列。

2、添加任务到调度队列中

使用dispatch_sync(<#dispatch_queue_t _Nonnull queue#>, <#^(void)block#>)函数或者dispatch_async(<#dispatch_queue_t _Nonnull queue#>, <#^(void)block#>)函数来同步或异步的执行任务。示例如下：

- (void)creatGCDQueue {
    //创建一个串行的队列
    dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_SERIAL);
    //向队列中添加同步任务1
    dispatch_sync(queue, ^{
        NSLog(@"%@:task1",[NSThread currentThread]);
    });
    //向队列中添加异步任务2
    dispatch_async(queue, ^{
        NSLog(@"%@:task2",[NSThread currentThread]);
    });
    
}

//打印信息：

image.png

上面的代码创建了一个串行的自定义队列，并且向队列中添加了一个同步的任务和一个异步的任务。需要注意，这里的同步和异步指的是针对当前代码运行所在的线程而言的。
从打印信息可以看出，同步的任务是在主线程中执行，异步的任务是在单独的线程中执行，由于我们创建的调度队列是串行的，因此先开启了任务1，后开启了任务2.

只有当调度队列是并行，而且向队列中添加的任务也是异步的时候，多任务才会实现并行异步执行。

实现如下：

- (void)creatGCDQueue {
    //创建一个并行的队列
    dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);
    //向队列中添加异步任务1
    dispatch_async(queue, ^{
        for (int i = 0; i < 15; i ++) {
            NSLog(@"%@ = %d:task1",[NSThread currentThread],i);
        }
    });
    //向队列中添加异步任务2
    dispatch_async(queue, ^{
        for (int i = 0; i < 15; i ++) {
            NSLog(@"%@ = %d:task2",[NSThread currentThread],i);
        }    });
    
}

3、使用队列组

通过前面的学习，我们现在已经可以运用队列多线程执行任务了，但是GCD的强大之处远远不止如此。看下面的例子。
如果有3个任务A、B、C，其中A与B是没有关系的，他们可以并行执行，C必须是A、B都结束之后才能执行，当然，实现这样的逻辑并不困难，使用KVO就可以实现，但是如果使用队列处理这样的逻辑，则代码会更加清晰简单。
可以使用dispatch_group_create()创建一个队列组，使用如下函数将队列添加到队列组中：

void dispatch_group_async(dispatch_group_t group,
    dispatch_queue_t queue,
    dispatch_block_t block);

队列中的队列是异步执行的，示例如下：

- (void)creatGCDGroup {
    //创建一个队列组
    dispatch_group_t group = dispatch_group_create();
    //创建一个异步队列
    dispatch_queue_t queue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);
    //添加任务
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 10; i ++) {
            NSLog(@"%@ = %d:task1",[NSThread currentThread],i);
        }
    });
    
    //添加任务
    dispatch_group_async(group, queue, ^{
        for (int i = 0; i < 10; i ++) {
            NSLog(@"%@ = %d:task2",[NSThread currentThread],i);
        }
    });
    
    //阻塞线程，直到前面的队列任务执行完成
    dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
    for (int i = 0; i < 10; i ++) {
        NSLog(@"%@ = %d:over",[NSThread currentThread],i);
    }
}

打印结果如下：

image.png

以上代码完美的实现了我们的任务依赖需求，可以看出GCD的强大了吧，复杂的任务逻辑关系因为GCD变得十分清晰简单。

4、GCD对循环任务的处理

说到循环，除了常规的while循环，for循环外，for-in也是开发中常用的一种循环方式。for-in循环通常来进行数组或字典的遍历，这种遍历通常不关心循环执行的顺序。使用GCD，配合设备的多核运算技术，我们可以将这种循环遍历的性能提升到极致，示例如下：

- (void)creatGCDApply {
    dispatch_apply(20, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t i) {
        NSLog(@"%@:%zu",[NSThread currentThread],i);
    });
}

打印信息如下：

image.png

从打印信息可以看出，循环是由多个不同的线程完成的，比如我们的设备是8核的CPU。因此每个线程单独在一个核执行，这将循环的运行效率提升到了极致。大大提高了运行速率。

5、GCD中的消息与信号

5.1Dispatch Source

在GCD框架中提供了dispatch_source_t类型的对象，dispatch_source_t类型的对象可以用来传递和接收某个消息。在任一线程上调用它的一个函数 dispatch_source_merge_data 后，会执行 Dispatch Source 事先定义好的句柄（可以把句柄简单理解为一个 block ）。
这个过程叫 Custom event ，用户事件。是 dispatch source 支持处理的一种事件。简单地说，这种事件是由你调用 dispatch_source_merge_data 函数来向自己发出的信号。
示例如下：

- (void)creatGCDSource {
    //创建一个数据对象，DISPATCH_SOURCE_TYPE_DATA_ADD的含义表示当数据变化时相加
    dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
    //设置响应分派源事件的block，在分派源指定的队列上运行
    dispatch_source_set_event_handler(source, ^{
        
        NSLog(@"%lu:sec",dispatch_source_get_data(source));//得到分派源的数据
        dispatch_async(dispatch_get_main_queue(), ^{
            //更新UI
        });
        
    });
    //启动
    dispatch_resume(source);
    
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
       
        //网络请求
        //向分派源发送事件，需要注意的是，不可以传递0值(事件不会被触发)，同样也不可以传递负数。
        dispatch_source_merge_data(source, 1);
    });

}

注意：DISPATCH_SOURCE_TYPE_DATA_ADD是将所有触发结果相加，最后统一执行响应，但是加入sleepForTimeInterval后，如果interval的时间越长，则每次触发都会响应，但是如果interval的时间很短，则会将触发后的结果相加后统一触发。这在更新UI时很有用，比如更新进度条时，没必要每次触发都响应，因为更新时还有其他的用户操作（用户输入，触碰等），所以可以统一触发

比如我们写一个进度条的示例：

- (void)creatGCDSource {
    //1、指定DISPATCH_SOURCE_TYPE_DATA_ADD，做成Dispatch Source(分派源)。设定Main Dispatch Queue 为追加处理的Dispatch Queue
       dispatch_source_t source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
       
       __block NSUInteger totalComplete = 0;
       
       dispatch_source_set_event_handler(source, ^{
           
           //当处理事件被最终执行时，计算后的数据可以通过dispatch_source_get_data来获取。这个数据的值在每次响应事件执行后会被重置，所以totalComplete的值是最终累积的值。
           NSUInteger value = dispatch_source_get_data(source);
           
           totalComplete += value;
           
           NSLog(@"进度：%@", @((CGFloat)totalComplete/100));
           
           NSLog(@":large_blue_circle:线程号：%@", [NSThread currentThread]);
       });
       
       //分派源创建时默认处于暂停状态，在分派源分派处理程序之前必须先恢复。
       dispatch_resume(source);
       
       dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
       
       //2、恢复源后，就可以通过dispatch_source_merge_data向Dispatch Source(分派源)发送事件:
    
       dispatch_async(queue, ^{
       
           for (NSUInteger index = 0; index < 100; index++) {
       
               dispatch_source_merge_data(source, 1);
       
               NSLog(@":recycle:线程号：%@~~~~~~~~~~~~i = %ld", [NSThread currentThread], index);
       
               sleep(0.1);
           }
       });

}

5.2、信号量 singer

信号量是GCD中一个很重要的概念，他的用法与消息的传递有所类似，其本示例代码如下：

- (void)creatGCDSinger {
    //创建一个信号，其中的参数是信号的初始值
    dispatch_semaphore_t singer = dispatch_semaphore_create(0);
    //发送信号，信号量+1
    dispatch_semaphore_signal(singer);
    //等待信号，当信号量大于0时，执行后面的代码，否则等待，第二个参数为等待的超时时长，下面设置的为一直等待
    dispatch_semaphore_wait(singer, DISPATCH_TIME_FOREVER);
    NSLog(@"singer");
}

注意，dispatch_semaphore_wait函数会阻塞当前线程，在主线程中要慎用。通过发送信号函数：dispatch_semaphore_signal（），可以使信号量+1，每次执行过等待信号后，信号量会-1，如此，我们可以很方便地控制不同队列中方法的执行流程。

5.2.1限制线程的最大并发数

- (void)creatGCDSinger {
    //创建一个信号，其中的参数是信号的初始值
    dispatch_semaphore_t singer = dispatch_semaphore_create(2);
    for (int i = 0; i < 15; i++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            //等待信号，当信号量大于0时，执行后面的代码，否则等待，第二个参数为等待的超时时长，下面设置的为一直等待
            dispatch_semaphore_wait(singer, DISPATCH_TIME_FOREVER);
            //doing
            sleep(1);
            //发送信号，信号量+1
            dispatch_semaphore_signal(singer);
        });
    }
}

如上述代码可知，总共异步执行15个任务，但是由于我们设置了值为2的信号量，每一次执行任务的时候信号量都会先-1，而在任务结束后使信号量加1，当信号量减到0的时候，说明正在执行的任务有2个，这个时候其它任务就会阻塞，直到有任务被完成时，这些任务才会执行。

注意，信号量的正常的使用顺序是先降低（dispatch_semaphore_wait）然后再提高（dispatch_semaphore_signal），这两个函数通常成对使用。

5.2.2阻塞发请求的线程

有些时候，我们需要阻塞发送请求的线程，比如在多个请求回调后统一操作的需求，而这些请求之间并没有顺序关系，且这些接口都会另开线程进行网络请求的。一般地，这种多线程完成后进行统一操作的需求都会使用队列组(dispatch_group_t)来完成，但是由于是异步请求，没等其异步回调之后，请求的线程就结束了，为此，就需要使用信号量来阻塞住发请求的线程。实现代码如下：

- (void)creatGCDSinger {
    //创建线程组
    dispatch_group_t group = dispatch_group_create();
    //获取队列
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //任务1
    dispatch_group_async(group, queue, ^{
       //请求1
        [self request1];
    });
    
    //任务2
    dispatch_group_async(group, queue, ^{
       //请求2
        [self request2];
    });
    
    //任务3
    dispatch_group_async(group, queue, ^{
       //请求3
        [self request3];
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
         NSLog(@"-------所有网络请求已请求完成-------");
     });
}

- (void)request1 {
    //创建信号量，并设置为0，信号量本质是资源数，为0表示用完，需要等待
    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
    //模拟网络请求-异步
    //每次网络请求成功或失败后，都让信号量+1，表示释放当前资源，其他线程可以抢占了
    [[KNetRequestManager share] getSomeData:^{
        //网络请求成功，发送信号
      dispatch_semaphore_signal(sema);
    } errorBlock:^{
        //网络请求失败，发送信号
        dispatch_semaphore_signal(sema);
    }];
    //如果信号量为0，表示没有资源可用，便一直等待，不再往下执行.只有当网络请求成功或失败时，才会往下走
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
}

- (void)request2 {
    //创建信号量，并设置为0，信号量本质是资源数，为0表示用完，需要等待
    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
    //模拟网络请求-异步
    //每次网络请求成功或失败后，都让信号量+1，表示释放当前资源，其他线程可以抢占了
    [[KNetRequestManager share] getSomeData:^{
        //网络请求成功，发送信号
      dispatch_semaphore_signal(sema);
    } errorBlock:^{
        //网络请求失败，发送信号
        dispatch_semaphore_signal(sema);
    }];
    //如果信号量为0，表示没有资源可用，便一直等待，不再往下执行
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
}

- (void)request3 {
    //创建信号量，并设置为0，信号量本质是资源数，为0表示用完，需要等待
    dispatch_semaphore_t sema = dispatch_semaphore_create(0);
    //模拟网络请求-异步
    //每次网络请求成功或失败后，都让信号量+1，表示释放当前资源，其他线程可以抢占了
    [[KNetRequestManager share] getSomeData:^{
        //网络请求成功，发送信号
      dispatch_semaphore_signal(sema);
    } errorBlock:^{
        //网络请求失败，发送信号
        dispatch_semaphore_signal(sema);
    }];
    //如果信号量为0，表示没有资源可用，便一直等待，不再往下执行
    dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
}

当然，我们也可以使用dispatch_group_enter和dispatch_group_leave来实现同样的功能：

- (void)creatGCDSinger {
    //创建线程组
    dispatch_group_t group = dispatch_group_create();
    //创建一个并发队列
    dispatch_queue_t queue = dispatch_queue_create("group.queue", DISPATCH_QUEUE_CONCURRENT);
    //任务1
     dispatch_group_enter(group);
    dispatch_group_async(group, queue, ^{
       //请求1
        [self request1WithGroup:group];
    });
    
    //任务2
    dispatch_group_enter(group);
    dispatch_group_async(group, queue, ^{
       //请求2
        [self request2WithGroup:group];
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
         NSLog(@"-------所有网络请求已请求完成-------");
     });
}

- (void)request1WithGroup:(dispatch_group_t)group {
    //模拟网络请求-异步
    [[KNetRequestManager share] getSomeData:^{
        //网络请求成功，调用level
      dispatch_group_leave(group);
    } errorBlock:^{
         //网络请求失败，调用level
        dispatch_group_leave(group);
    }];

}

- (void)request2WithGroup:(dispatch_group_t)group
    //模拟网络请求-异步
    [[KNetRequestManager share] getSomeData:^{
        //网络请求成功，调用level
      dispatch_group_leave(group);
    } errorBlock:^{
         //网络请求失败，调用level
        dispatch_group_leave(group);
    }];
}

5.2.3信号量控制网络请求顺序

- (void)creatGCDSinger {
    //创建semp
    dispatch_semaphore_t semp = dispatch_semaphore_create(1);
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //任务1
    dispatch_async(queue, ^{
        //信号量-1
        dispatch_semaphore_wait(semp, DISPATCH_TIME_FOREVER);
        //模拟网络请求
        //模拟网络请求-异步
        //每次网络请求成功或失败后，都让信号量+1，表示释放当前资源，其他线程可以抢占了
        [[KNetRequestManager share] getSomeData:^{
            //网络请求成功，发送信号
          dispatch_semaphore_signal(sema);
        } errorBlock:^{
            //网络请求失败，发送信号
            dispatch_semaphore_signal(sema);
        }];
    });
    //任务2
    dispatch_async(queue, ^{
        //信号量-1
        dispatch_semaphore_wait(semp, DISPATCH_TIME_FOREVER);
        //模拟网络请求
        //模拟网络请求-异步
        //每次网络请求成功或失败后，都让信号量+1，表示释放当前资源，其他线程可以抢占了
        [[KNetRequestManager share] getSomeData:^{
            //网络请求成功，发送信号
          dispatch_semaphore_signal(sema);
        } errorBlock:^{
            //网络请求失败，发送信号
            dispatch_semaphore_signal(sema);
        }];
    });
}

6、队列的挂起和开启

在GCD框架中还提供了暂停与开始任务队列的方法，使用下面的函数可以将队列或队列组暂时挂起和开启：

//挂起队列或队列组
void dispatch_suspend(dispatch_object_t object);
//开启队列或队列组
void dispatch_resume(dispatch_object_t object);

注意：在暂停队列时，队列中正在执行的任务并不会中断，未开启的任务会被挂起。

7、数据存储的线程安全问题-多度单写

在进行多线程编程时，或许总会遇到这一类问题：数据的竞争与线程的安全。这些问题如果通过程序手动来控制，则难度将会非常大。CGD同样为我们简单地解决了这样的问题。
首先，如果只是在读取数据，而不对数据做任何修改，那么我们并不需要处理安全问题，可以让多个任务同时进行读取。可是如果要对数据进行写操作，那么在同一时间，我们就必须只能有一个任务在写，CGD中有一个方法帮我们完美地解决了这个问题，示例如下：

- (void)creatCGDReadAndWriter {
    //创建一个队列
    dispatch_queue_t queue = dispatch_queue_create("oneQueue", DISPATCH_QUEUE_CONCURRENT);
    //多个任务同时执行读操作
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"read1:%d",i);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"read2:%d",i);
        }
    });
    
    //执行写操作
    /*
     下面这个函数在加入队列时不会执行，会等待已经开始的异步执行全部完成后再执行，并且在执行时会阻塞其他任务
     当执行完成后，其他任务重新进入异步执行
     */
    dispatch_barrier_async(queue, ^{
        for (int i = 0; i < 5; i ++) {
             NSLog(@"writer:%d",i);
        }
    });
    //绩效执行异步操作
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"read3:%d",i);
        }
    });
    dispatch_async(queue, ^{
        for (int i = 0; i < 5; i++) {
            NSLog(@"read4:%d",i);
        }
    });
}

打印信息：

image.png

从打印信息可以看出读操作是异步进行的，写操作是等待当前任务结束后阻塞任务队列独立进行的，当写操作结束后队列恢复异步执行读操作，这正是我们需要的效果。