iOS-GCD系列之dispatch_queue_t

在一个即时聊天项目中创建一个同步任务来执行数据库操作，在获取数据时忽略了这一点，获取数据时又将同步任务添加到队列中，导致应用启动后事件无响应，甚至导致了死锁，使用应用crash。找了半天发现原来是对GCD的使用不当，引起的死锁。主要还是没有对GCD深入了解，对有些方法也是现学现用，才会引起这样的问题，因此准备用此系列文章记录GCD的学习使用过程。

名词解释

GCD：全称是Grand Central Dispatch，中文名字大脑中枢派发，基于C语言的是苹果公司为解决多核并行问题研发，线程及生命周期都有系统自动管理。

任务：执行什么操作
队列：用来存放任务，将需要执行的任务添加到队列中，队列会遵循FIFO原则（先进先出、后进后出），将队列中的任务取出，放到对应的线程中执行

同步：不创建新的线程，只在当前线程中执行任务
异步：创建多条线程执行任务

串行：同一时间每次只能执行一个任务，当前任务未完成下一个任务只能在队列中等候
并发：同一时间可以执行多个任务

死锁：两个或多个任务互相等待形成死循环阻塞了线程，甚至导致应用无响应

关系

	串行	并行	主队列
同步	没有开启新线程串行执行任务	没有开启新线程串行执行任务	发生死锁
异步	开启新线程串行执行任务	开启新线程并发执行任务	没有开启新线程串行执行任务

队列

创建队列使用dispatch_queue_create，有两个参数，第一个参数是队列的名称，第二个参数是队列类型，通常创建串行队列都传NULL，我们也可以使用dispatch_queue_attr_t定义好的常量创建同步/并发队列

/**
dispatch_queue_attr_t
DISPATCH_QUEUE_SERIAL: 同步队列
DISPATCH_QUEUE_CONCURRENT：并发队列
*/
dispatch_queue_t dispatch_queue_create ( const char *label, dispatch_queue_attr_t attr );

串行队列

手动创建串行队列，当任务需要按特定的顺序执行时，就需要使用串行调度队列，串行调度队列每次只能执行一个任务
1
dispatch_queue_t queue = dispatch_queue_create("com.wynter.customQueue", NULL);
获取串行主队列，应用程序创建时系统自带串行队列，主队列中的任务都会在主线程中执行，一般会用于更新UI
1
dispatch_queue_t queue = dispatch_get_main_queue();

并发队列

全局并发队列由系统提供，供整个应用使用，不需要我们手动创建可以同时并行执行多个任务，同样也遵循FIFO原则

/**
队列优先级
DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高
DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）
DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低
DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台
*/
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 
// dispatch_queue_t queue = dispatch_queue_create("com.wynter.customQueue", DISPATCH_QUEUE_CONCURRENT);

实战

同步/异步串行队列

//  创建串行队列
dispatch_queue_t queue = dispatch_queue_create("com.wynter.customQueue", DISPATCH_QUEUE_SERIAL);
NSLog(@"Begin");
// 异步串行队列
dispatch_async(queue, ^{
    sleep(3);
    NSLog(@"异步任务1，当前线程：%@", [NSThread currentThread]);
});
NSLog(@"队列外1，当前线程：%@", [NSThread currentThread]);
dispatch_async(queue, ^{
    sleep(2);
    NSLog(@"异步任务2，当前线程：%@", [NSThread currentThread]);
});
NSLog(@"队列外2，当前线程：%@", [NSThread currentThread]);
// 同步串行队列
dispatch_sync(queue, ^{
    NSLog(@"同步任务1，当前线程：%@", [NSThread currentThread]);
});
NSLog(@"队列外3，当前线程：%@", [NSThread currentThread]);
// 异步串行队列
dispatch_async(queue, ^{
    sleep(1);
    NSLog(@"异步任务3，当前线程：%@", [NSThread currentThread]);
});
NSLog(@"End");
/**
 2017-12-11 10:25:44.915490+0800 GCD[24560:5161766] Begin
 2017-12-11 10:25:44.915783+0800 GCD[24560:5161766] 队列外1，当前线程：<NSThread: 0x604000067800>{number = 1, name = main}
 2017-12-11 10:25:44.915957+0800 GCD[24560:5161766] 队列外2，当前线程：<NSThread: 0x604000067800>{number = 1, name = main}
 2017-12-11 10:25:47.920174+0800 GCD[24560:5162003] 异步任务1，当前线程：<NSThread: 0x60000027d6c0>{number = 3, name = (null)}
 2017-12-11 10:25:49.920629+0800 GCD[24560:5162003] 异步任务2，当前线程：<NSThread: 0x60000027d6c0>{number = 3, name = (null)}
 2017-12-11 10:25:49.920987+0800 GCD[24560:5161766] 同步任务1，当前线程：<NSThread: 0x604000067800>{number = 1, name = main}
 2017-12-11 10:25:49.921231+0800 GCD[24560:5161766] 队列外3，当前线程：<NSThread: 0x604000067800>{number = 1, name = main}
 2017-12-11 10:25:49.921389+0800 GCD[24560:5161766] End
 2017-12-11 10:25:50.926144+0800 GCD[24560:5162003] 异步任务3，当前线程：<NSThread: 0x60000027d6c0>{number = 3, name = (null)}
 */

小结：

同步串行队列使用主线程顺序执行任务，如果当前任务没有完成，不会继续执行同步块以外的其它代码
异步串行队列会创建一条新的线程，在当前线程中顺序执行任务，队列外的代码会在主线程中顺序执行，不受队列中任务的干扰

同步/异步并发队列

// 获取全局并发队列
dispatch_queue_t queue =  dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
// 手动创建并发队列
//dispatch_queue_t queue =  dispatch_queue_create("com.wynter.customQueue", DISPATCH_QUEUE_CONCURRENT);
NSLog(@"Begin");
// 异步并发队列
dispatch_async(queue, ^{
    sleep(3);
    NSLog(@"异步任务1，当前线程：%@", [NSThread currentThread]);
});
NSLog(@"队列外1，当前线程：%@", [NSThread currentThread]);
dispatch_async(queue, ^{
    sleep(2);
    NSLog(@"异步任务2，当前线程：%@", [NSThread currentThread]);
});
NSLog(@"队列外2，当前线程：%@", [NSThread currentThread]);
// 同步并发队列
dispatch_sync(queue, ^{
    NSLog(@"同步任务1，当前线程：%@", [NSThread currentThread]);
});
NSLog(@"队列外3，当前线程：%@", [NSThread currentThread]);
// 异步串行队列
dispatch_async(queue, ^{
    sleep(1);
    NSLog(@"异步任务3，当前线程：%@", [NSThread currentThread]);
});
NSLog(@"End");
/**
 2017-12-11 10:23:58.493818+0800 GCD[24510:5157656] Begin
 2017-12-11 10:23:58.494137+0800 GCD[24510:5157656] 队列外1，当前线程：<NSThread: 0x604000263000>{number = 1, name = main}
 2017-12-11 10:23:58.494333+0800 GCD[24510:5157656] 队列外2，当前线程：<NSThread: 0x604000263000>{number = 1, name = main}
 2017-12-11 10:23:58.494488+0800 GCD[24510:5157656] 同步任务1，当前线程：<NSThread: 0x604000263000>{number = 1, name = main}
 2017-12-11 10:23:58.494919+0800 GCD[24510:5157656] 队列外3，当前线程：<NSThread: 0x604000263000>{number = 1, name = main}
 2017-12-11 10:23:58.495081+0800 GCD[24510:5157656] End
 2017-12-11 10:23:59.498625+0800 GCD[24510:5158018] 异步任务3，当前线程：<NSThread: 0x600000669080>{number = 3, name = (null)}
 2017-12-11 10:24:00.495907+0800 GCD[24510:5158020] 异步任务2，当前线程：<NSThread: 0x600000662980>{number = 4, name = (null)}
 2017-12-11 10:24:01.499261+0800 GCD[24510:5158016] 异步任务1，当前线程：<NSThread: 0x6000006692c0>{number = 5, name = (null)}
 */

小结：

同步并发队列任务不会创新线程，依然在主线程中执行，与同步串行队列效果相同
异步并发队列会依据并发任务量，创建对应的线程数量，实际开发中异步并发任务顺序是不确定的。

扩展

合理并发

在开发中并不是并发线程越多越好，线程多往往对也会以牺牲性能为代价，并发线程过多，并且不能很好的控制线程也有可能因为一个线程的阻塞或者死锁导致整个应用崩溃。

那么开多少个线程较为合理呢，这个没有确切的答案。最早了解到的是CPU核数*2，现在CPU性能已经提升了N个档位，所以具体要根据业务而定了，非必要情况还是控制在6个线程以内为好。我们可以使用dispatch_semaphore(信号量)来控制并发线程数量，之后会有详细介绍dispatch_semaphore的使用。

设置队列优先级

在使用dispatch_queue_create创建队列的时候会发现，并没有设置队列优先级的选项，而全局队列则有高、中、低、后台四个等级可供选择，但是我们可以使用、dispatch_queue_attr_make_with_qos_class或者dispatch_set_target_queue方法来设置队列的优先级，dispatch_queue_create创建队列的优先级跟全局队列的默认优先级一样。

通过dispatch_queue_attr_make_with_qos_class方法设置队列的优先级

/*
 *  QOS和全局并发队列优先级的映射关系
 *  - DISPATCH_QUEUE_PRIORITY_HIGH:         QOS_CLASS_USER_INITIATED
 *  - DISPATCH_QUEUE_PRIORITY_DEFAULT:      QOS_CLASS_DEFAULT
 *  - DISPATCH_QUEUE_PRIORITY_LOW:          QOS_CLASS_UTILITY
 *  - DISPATCH_QUEUE_PRIORITY_BACKGROUND:   QOS_CLASS_BACKGROUND
*/
dispatch_queue_attr_t queue_attr = dispatch_queue_attr_make_with_qos_class (DISPATCH_QUEUE_SERIAL, QOS_CLASS_UTILITY,-1);
dispatch_queue_t queue = dispatch_queue_create("com.wynter.customQueue", queue_attr);

通过dispatch_set_target_queue方法设置队列的优先级

dispatch_queue_t serialQueue = dispatch_queue_create("com.wynter.customQueue",NULL);  
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW,0);  
 
// serialQueue队列参照globalQueue队列的优先级（DISPATCH_QUEUE_PRIORITY_LOW）
dispatch_set_target_queue(serialQueue, globalQueue);

使用栅栏控制并发队列中个别任务执行

dispatch_barrier_async异步栅栏用于等待控制队列中前面的任务执行完毕后自己才执行，而它后面的任务需等待它完成之后才执行。异步栅栏不影响主线程中的任务执行顺序，但队列中的任务必须上面的规则。dispatch_barrier_sync同步栅栏则会阻塞主线程等待当前任务完成后才能按照原队列的规则执行。

dispatch_queue_t queue = dispatch_queue_create("com.wynter.customQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
    NSLog(@"async_1");
});
dispatch_barrier_async(queue, ^{
    sleep(2);
    NSLog(@"hi,barrier");
});
dispatch_async(queue, ^{
   NSLog(@"async_2");
});

异步并发迭代任务

当我们需要执行循环异步处理任务时，可以考虑使用dispatch_apply来替换掉for循环，来并发地循环迭代任务。需要注意的是dispatch_apply的block内部异步并发，从下面代码打印End可以看出，dispatch_apply是等待其所有的循环运行完毕才往下执行。

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
size_t count = 10;
dispatch_apply(count, queue, ^(size_t i) {
    NSLog(@"%zu", i);
});
NSLog(@"End");
/**
 2017-12-11 10:30:07.152514+0800 GCD[25447:5470863] 0
 2017-12-11 10:30:07.152514+0800 GCD[25447:5471097] 1
 2017-12-11 10:30:07.152527+0800 GCD[25447:5471095] 2
 2017-12-11 10:30:07.152558+0800 GCD[25447:5471099] 3
 2017-12-11 10:30:07.152731+0800 GCD[25447:5471097] 4
 2017-12-11 10:30:07.152731+0800 GCD[25447:5470863] 5
 2017-12-11 10:30:07.152849+0800 GCD[25447:5471095] 6
 2017-12-11 10:30:07.152988+0800 GCD[25447:5471099] 7
 2017-12-11 10:30:07.153095+0800 GCD[25447:5471097] 8
 2017-12-11 10:30:07.153108+0800 GCD[25447:5470863] 9
 2017-12-11 10:30:07.154095+0800 GCD[25447:5470863] End
 */

暂停/恢复队列

dispatch_suspend不能保证可以立即停止队列上正在运行的block任务，而是在当前block任务执行完成后，暂停后续队列中的任务执行。

dispatch_queue_t queue = dispatch_queue_create("com.wynter.customQueue", NULL);
// 暂停指定队列
dispatch_suspend(queue);
// 恢复指定队列
dispatchp_resume(queue);

总结

为避免发生死锁，少用dispatch_sync，建议尽量不要是使用同步串行队列处理任务
不建议创建多个串行队列来执行任务，应该在全局并发队列中完成任务
避免多级嵌套使用GCD