GCD（Grand Central Dispatch）
什么是GCD
Grand Central Dispatch（GCD）是异步执行任务的技术之一。一般将应用程序中记述的线程管理用的代码在系统级中实现。开发者只需要定义想执行的任务并追加到适当的Dispatch Queue中，GCD就能生成必要的线程并计划执行任务。由于线程管理是作为系统的一部分来实现的，因此可统一管理，也可执行任务，这样就比以前的线程更有效率。
例子：
//让处理在后台线程中执行
dispatch async(queue, ^{
/*
*长时间处理
*例如AR用画像识别*例如数据库访问
*/
/*
*长时间处理结束， 主线程使用该处理结果。
*/
//让处理在主线程中执行
dispatch_async(dispatch_get main_queue(), ^{
/*
*只在主线程可以执行的处理
*例如用户界面更新
*/
});
});
其实在GCD之前，Cocoa框架提供了NSObject类的performSelectorInBackground:withObject 实例方法和 performSelectorOnMainThread 实例方法等简单的多线程编程技术。
performSelector系方法要比使用NSThread 类进行多线程编程简单，但与之前使用GCD的源代码相比，结果一目了然。相比performSelector系方法，GCD更为简洁。如果使用GCD，不仅不必使用NSThread类或performSelector系方法这些过时的API，更可以通过GCD提供的系统级线程管理提高执行效率。
performSelector方法：
GCD的优点：
- GCD可用于多核的并行运算
- GCD会自动利用更多的CPU内核（比如双核、四核）
- GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
- 程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码
任务和队列
任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在GCD中是放在block中的。执行任务有两种方式：同步执行和异步执行。两者的主要区别是：是否具备开启新线程的能力。
- 同步执行（sync）：只能在当前线程中执行任务，不具备开启新线程的能力
- 异步执行（async）：可以在新的线程中执行任务，具备开启新线程的能力
队列：这里的队列指任务队列，即用来存放任务的队列。队列是一种特殊的线性表，采用FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。在GCD中有两种队列：串行队列和并发队列。
- 并发队列（Concurrent Dispatch Queue）：可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）【并发功能只有在异步（dispatch_async）函数下才有效】
- 串行队列（Serial Dispatch Queue）：让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）
队列的创建方式
可以使用dispatch_queue_create来创建对象，需要传入两个参数，第一个参数表示队列的唯一标识符，用于DEBUG，可为空；第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL表示串行队列，DISPATCH_QUEUE_CONCURRENT表示并发队列。
// 串行队列的创建方法
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue= dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
对于并发队列，还可以使用dispatch_get_global_queue来创建全局并发队列。GCD默认提供了全局的并发队列，需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。
任务的创建方法
// 同步执行任务创建方法
dispatch_sync(queue, ^{
NSLog(@"%@",[NSThread currentThread]); // 这里放任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
NSLog(@"%@",[NSThread currentThread]); // 这里放任务代码
});
我们知道有两种任务，加上主队列有三种队列，那么就有了6种组合方式，我们来看看6种组合方式的不同效果：
- 并发队列 + 同步执行
- 并发队列 + 异步执行
- 串行队列 + 同步执行
- 串行队列 + 异步执行
- 主队列 + 同步执行
- 主队列 + 异步执行
六种情况的例子
1.并发队列 + 同步执行
- (void)syncConcurrent {
// 并发队列 + 同步执行
NSLog(@"syncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@", [NSThread currentThread]);
}
});
NSLog(@"syncConcurrent---end");
}
运行结果：
从并发队列 + 同步执行中可以看到，所有任务都是在主线程中执行的。由于只有一个线程，所以任务只能一个一个执行。
同时我们还可以看到，所有任务都在打印的syncConcurrent—begin和syncConcurrent—end之间，这说明任务是添加到队列中马上执行的。
2. 并发队列 + 异步执行
- (void)asyncConcurrent {
//并发队列 + 异步执行
NSLog(@"asyncConcurrent---begin");
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@", [NSThread currentThread]);
}
});
NSLog(@"asyncConcurrent---end");
}
运行结果：
在并发队列 + 异步执行中可以看出，除了主线程，又开启了3个线程，并且任务是交替着同时执行的。
另一方面可以看出，所有任务是在打印的syncConcurrent—begin和syncConcurrent—end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始异步执行。
3.串行队列 + 同步执行
- (void)syncSerial {
//串行队列 + 同步执行
NSLog(@"syncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@", [NSThread currentThread]);
}
});
NSLog(@"syncSerial---end");
}
在串行队列 + 同步执行可以看到，所有任务都是在主线程中执行的，并没有开启新的线程。而且由于串行队列，所以按顺序一个一个执行。
同时我们还可以看到，所有任务都在打印的syncConcurrent—begin和syncConcurrent—end之间，这说明任务是添加到队列中马上执行的。
4.串行队列 + 异步执行
- (void)asyncSerial {
//串行队列 + 异步执行
NSLog(@"asyncSerial---begin");
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_SERIAL);
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@", [NSThread currentThread]);
}
});
NSLog(@"asyncSerial---end");
}
运行结果：
在串行队列 + 异步执行可以看到，开启了一条新线程，但是任务还是串行，所以任务是一个一个执行。
另一方面可以看出，所有任务是在打印的syncConcurrent—begin和syncConcurrent—end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行。
5. 主队列 + 同步执行
- (void)syncMain {
//主队列 + 同步执行
NSLog(@"syncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@", [NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@", [NSThread currentThread]);
}
});
NSLog(@"syncMain---end");
}
这段代码运行会崩溃，编译器给出如下报错：
仔细检查可以发现，我们这段代码就是在主线程中运行，而在主线程中将任务放在了主队列中，同步执行有个特点，就是对于任务是立马执行的。那么当我们把第一个任务放进主队列中，它就会立马执行。但是主线程现在正在处理syncMain方法，所以任务需要等syncMain执行完才能执行。而syncMain执行到第一个任务的时候，又要等第一个任务执行完才能往下执行第二个和第三个任务。
那么，现在的情况就是syncMain方法和第一个任务都在等对方执行完毕。这样大家互相等待，所以就卡住了，所以我们的任务执行不了，而且syncMain—end也没有打印。
要是如果不再主线程中调用，而在其他线程中调用会如何呢？
先将任务放在其他线程，然后再回到主线程：
//将方法调用改为
dispatch_queue_t queue = dispatch_queue_create("test.queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
[self syncMain];
});
在其他线程中使用主队列 + 同步执行可看到：所有任务都是在主线程中执行的，并没有开启新的线程。而且由于主队列是串行队列，所以按顺序一个一个执行。
同时我们还可以看到，所有任务都在打印的syncConcurrent—begin和syncConcurrent—end之间，这说明任务是添加到队列中马上执行的。
6. 主队列 + 异步执行
- (void)asyncMain {
//主队列 + 异步执行
NSLog(@"asyncMain---begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"1------%@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"2------%@", [NSThread currentThread]);
}
});
dispatch_async(queue, ^{
for (int i = 0; i < 2; ++i) {
NSLog(@"3------%@", [NSThread currentThread]);
}
});
NSLog(@"asyncMain---end");
}
我们发现所有任务都在主线程中，虽然是异步执行，具备开启线程的能力，但因为是主队列，所以所有任务都在主线程中，并且一个接一个执行。
另一方面可以看出，所有任务是在打印的syncConcurrent—begin和syncConcurrent—end之后才开始执行的。说明任务不是马上执行，而是将所有任务添加到队列之后才开始同步执行。
GCD线程之间的通讯
在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的操作放在其他线程，比如说图片下载、文件上传等耗时操作。而当我们有时候在其他线程完成了耗时操作时，需要回到主线程，那么就用到了线程之间的通讯。
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
for (int i = 0; i < 6; ++i) {
NSLog(@"1------%@",[NSThread currentThread]);
}
// 回到主线程
dispatch_async(dispatch_get_main_queue(), ^{
NSLog(@"2-------%@",[NSThread currentThread]);
});
});
输出结果：
可以看到在其他线程中先执行操作，执行完了之后回到主线程执行主线程的相应操作。
GCD的栅栏方法
我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。
- (void)barrier {
//GCD栅栏方法
dispatch_queue_t queue = dispatch_queue_create("666", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"----1-----%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"----2-----%@", [NSThread currentThread]);
});
// dispatch_barrier_async(queue, ^{
// NSLog(@"----barrier-----%@", [NSThread currentThread]);
// });
dispatch_async(queue, ^{
NSLog(@"----3-----%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"----4-----%@", [NSThread currentThread]);
});
}
首先我们把栅栏方法注释起来，运行试试：
我们会发现四个数字几乎同时打印，每次顺序是随机的，这时候把栅栏方法加上。
dispatch_barrier_async(queue, ^{
NSLog(@"----barrier-----%@", [NSThread currentThread]);
});
GCD的延时执行方法
当我们需要延迟执行一段代码时，就需要用到GCD的dispatch_after方法。
- (void)after {
NSLog(@"run -- 0");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2秒后异步执行这里的代码...
NSLog(@"run -- 2");
});
}
GCD的一次性代码(只执行一次)
我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了GCD的dispatch_once方法。使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次。
[self once];
[self once];
- (void)once {
//GCD的一次性代码(只执行一次)
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
NSLog(@"666");
});
}
运行结果：
GCD的队列组
有时候我们会有这样的需求：分别异步执行2个耗时操作，然后当2个耗时操作都执行完毕后再回到主线程执行操作。这时候我们可以用到GCD的队列组。
- 我们可以先把任务放到队列中，然后将队列放入队列组中。
- 调用队列组的dispatch_group_notify回到主线程执行操作。
- (void)group {
//GCD的队列组
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
int i = 0;
while (i < 100) {
NSLog(@"1");
i++;
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 执行1个耗时的异步操作
int i = 0;
while (i < 100) {
NSLog(@"2");
i++;
}
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后，回到主线程...
NSLog(@"3");
});
}
运行结果：
dispatch_set_target_queue
这个函数有两个作用：
1.改变队列的优先级。
2.防止多个串行队列的并发执行。
改变队列的优先级
dispatch_queue_create方法生成的串行队列合并发队列的优先级都是与默认优先级的Globle Dispatch Queue一致。
如果想要变更某个队列的优先级，需要使用dispatch_set_target_queue函数。
//需求：生成一个后台的串行队列
dispatch_queue_t queue = dispatch_queue_create("queue", NULL);
dispatch_queue_t bgQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
//第一个参数：需要改变优先级的队列；
//第二个参数：目标队列
dispatch_set_target_queue(queue, bgQueue);
防止多个串行队列的并发执行
如果是将任务追加到5个串行队列中，那么这些任务就会并发执行。因为每个串行队列都会创建一个线程，这些线程会并发执行。
如果将多个串行的queue使用dispatch_set_target_queue指定到了同一目标，那么这多个串行queue在目标queue上就是同步执行的，不再是并行执行。
将串行队列加入指定优先级队列，会按照加入优先级队列的顺序依次执行串行队列。
dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue3 = dispatch_queue_create("test.3", DISPATCH_QUEUE_SERIAL);
dispatch_set_target_queue(queue1, targetQueue);
dispatch_set_target_queue(queue2, targetQueue);
dispatch_set_target_queue(queue3, targetQueue);
dispatch_async(queue1, ^{
NSLog(@"1 in");
[NSThread sleepForTimeInterval:3.f];
NSLog(@"1 out");
});
dispatch_async(queue2, ^{
NSLog(@"2 in");
[NSThread sleepForTimeInterval:2.f];
NSLog(@"2 out");
});
dispatch_async(queue3, ^{
NSLog(@"3 in");
[NSThread sleepForTimeInterval:1.f];
NSLog(@"3 out");
});
输出结果：
dispatch_suspend/dispatch_resume
dispatch_suspend并不会立即暂停正在运行的block，而是在当前block执行完成后，暂停后续的block执行。
// 挂起指定队列
dispatch_suspend(queue);
// 恢复指定队列
dispatchp_resume(queue);
dispatch_queue_t queue = dispatch_queue_create("com.test.gcd", DISPATCH_QUEUE_SERIAL);
//提交第一个block，延时5秒打印。
dispatch_async(queue, ^{
sleep(5);
NSLog(@"After 5 seconds...");
});
//提交第二个block，也是延时5秒打印
dispatch_async(queue, ^{
sleep(5);
NSLog(@"After 5 seconds again...");
});
//延时一秒
NSLog(@"sleep 1 second...");
sleep(1);
//挂起队列
NSLog(@"suspend...");
dispatch_suspend(queue);
//延时10秒
NSLog(@"sleep 10 second...");
sleep(10);
//恢复队列
NSLog(@"resume...");
dispatch_resume(queue);
输出结果：
线程安全
为了保证线程安全，我们之前了解过互斥锁，在书上给了我们dispatch_semaphore方法，我们总结为三点：
1.synchronized加锁，属于互斥锁，当有线程执行锁住的代码的时候，其他线程会进入休眠，需要唤醒后才能继续执行，性能较低。
dispatch_async(dispatch_get_global_queue(0, 0), ^{
@synchronized (self) {
//加锁保证block中执行完成才会执行其他的
NSLog(@"1开始");
sleep(2);
NSLog(@"1结束");
}
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
@synchronized (self) {
NSLog(@"2开始");
sleep(2);
NSLog(@"2结束");
}
});
2.信号量semaphore加锁，属于自旋锁，当有线程执行锁住的代码的时候，其他线程会进入死循环的等待，当解锁后会立即执行，性能较高。
提供了三种函数：
- dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量（同时有几个线程可以执行，一般是1）
- dispatch_semaphore_wait：可以使总信号量减1，当信号总量小于0时就会一直等待（阻塞所在线程），否则就可以正常执行，这个放在要执行的代码的前面。
- dispatch_semaphore_signal：发送一个信号，让信号总量加1，代码执行完成之后使用，使其他线程可以继续执行
dispatch_semaphore_t semalook = dispatch_semaphore_create(1);
dispatch_async(dispatch_get_global_queue(0, 0), ^{
dispatch_semaphore_wait(semalook, DISPATCH_TIME_FOREVER);
NSLog(@"1开始");
sleep(2);
NSLog(@"1结束");
dispatch_semaphore_signal(semalook);
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
dispatch_semaphore_wait(semalook, DISPATCH_TIME_FOREVER);
NSLog(@"2开始");
sleep(2);
NSLog(@"2结束");
dispatch_semaphore_signal(semalook);
});
3.NSLock
NSLock *lock = [[NSLock alloc]init];
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[lock lock];
NSLog(@"1开始");
sleep(2);
NSLog(@"1结束");
[lock unlock];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[lock lock];
NSLog(@"2开始");
sleep(2);
NSLog(@"2结束");
[lock unlock];
});
三种例子输出：
