iOS 开发之 GCD 不同场景使用 本文在iOS 开发值 GCD 基础 的基础上，继续总结了 GCD 的一些API 和在不同场景下的使用。 GCD 栅栏方法：dispatch_barrier_async 我们有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于 栅栏 一样的一个方法将两组异步执行的操作组给分割起来，当然这里的操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。 dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行. 示意如图： /** * 栅栏方法 dispatch_barrier_async */ - (void)barrier { // 1. 创建并发队列队列 dispatch_queue_t queue = dispatch_queue_create("com.xiaoyouPrince", DISPATCH_QUEUE_CONCURRENT); // 2. 添加异步任务 dispatch_async(queue, ^{ // 追加任务1 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程 } }); dispatch_async(queue, ^{ // 追加任务2 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程 } }); // 栅栏任务 dispatch_barrier_async(queue, ^{ // 追加任务 barrier for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程 } }); dispatch_async(queue, ^{ // 追加任务3 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程 } }); dispatch_async(queue, ^{ // 追加任务4 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"4---%@",[NSThread currentThread]); // 打印当前线程 } }); } ------------------打印结果----------------- 1---{number = 4, name = (null)} 2---{number = 3, name = (null)} 1---{number = 4, name = (null)} 2---{number = 3, name = (null)} barrier---{number = 4, name = (null)} barrier---{number = 4, name = (null)} 4---{number = 3, name = (null)} 3---{number = 4, name = (null)} 4---{number = 3, name = (null)} 3---{number = 4, name = (null)} ------------------打印结果----------------- 在dispatch_barrier_async相关代码执行结果中可以看出： 在执行完栅栏前面的操作之后，才执行栅栏操作，最后再执行栅栏后边的操作 GCD 延时执行方法：dispatch_after 我们经常会遇到这样的需求：在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。 需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。 /** * 延时执行方法 dispatch_after */ - (void)after { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程 NSLog(@"after---begin"); dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0* NSEC_PER_SEC)), dispatch_get_main_queue(), ^{ // 2.0秒后异步追加任务代码到主队列，并开始执行 NSLog(@"after---%@",[NSThread currentThread]); // 打印当前线程 }); } 输出结果： 2018-08-29 17:53:08.713784+0800 GCD-demo[20282:5080295] currentThread---{number = 1, name = main} 2018-08-29 17:53:08.713962+0800 GCD-demo[20282:5080295] after---begin 2018-08-29 17:53:10.714283+0800 GCD-demo[20282:5080295] after---{number = 1, name = main} 在dispatch_after相关代码执行结果中可以看出：在打印 after---begin 之后大约 2.0 秒的时间，打印了 after---{number = 1, name = main} GCD 一次性代码（只执行一次）：dispatch_once 我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 函数。使用dispatch_once 函数能保证某段代码在程序运行过程中只被执行1次，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。 /** * 一次性代码（只执行一次）dispatch_once */ - (void)once { static dispatch_once_t onceToken; dispatch_once(&onceToken, ^{ // 只执行1次的代码(这里面默认是线程安全的) }); } GCD 快速迭代方法：dispatch_apply 通常我们会用 for 循环遍历，但是 GCD 给我们提供了快速迭代的函数dispatch_apply。dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。 我们可以利用异步队列同时遍历。比如说遍历 0~5 这6个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply可以同时遍历多个数字。 /** * 快速迭代方法 dispatch_apply */ - (void)apply { dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); NSLog(@"apply---begin"); dispatch_apply(6, queue, ^(size_t index) { NSLog(@"%zd---%@",index, [NSThread currentThread]); }); NSLog(@"apply---end"); } --------------------输出结果：------------------- apply---begin 1---{number = 3, name = (null)} 0---{number = 1, name = main} 2---{number = 4, name = (null)} 3---{number = 5, name = (null)} 4---{number = 3, name = (null)} 5---{number = 1, name = main} apply---end --------------------输出结果：------------------- 从 dispatch_apply 相关代码执行结果中可以看出： 0~5 打印顺序不定，最后打印了 apply---end。 因为是在并发队列中异步队执行任务，所以各个任务的执行时间长短不定，最后结束顺序也不定。但是apply---end一定在最后执行。这是因为 dispatch_apply 函数会等待全部任务执行完毕。 GCD 的队列组：dispatch_group 有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。 调用队列组的 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中。或者使用队列组的 dispatch_group_enter、dispatch_group_leave 组合 来实现dispatch_group_async。 调用队列组的 dispatch_group_notify 回到指定线程执行任务。或者使用 dispatch_group_wait回到当前线程继续向下执行（会阻塞当前线程）。 dispatch_group_notify 监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。 /** * 队列组 dispatch_group_notify */ - (void)groupNotify { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程 NSLog(@"group---begin"); // 1. 创建 group dispatch_group_t group = dispatch_group_create(); // 2. 异步执行组内的全局队列任务 dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任务1 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程 } }); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任务2 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程 } }); dispatch_group_notify(group, dispatch_get_main_queue(), ^{ // 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程 } NSLog(@"group---end"); }); } -------------------输出结果：----------------- currentThread---{number = 1, name = main} group---begin 1---{number = 4, name = (null)} 2---{number = 3, name = (null)} 2---{number = 3, name = (null)} 1---{number = 4, name = (null)} 3---{number = 1, name = main} 3---{number = 1, name = main} group---end 从dispatch_group_notify相关代码运行输出结果可以看出： 当所有任务都执行完成之后，才执行 dispatch_group_notify block 中的任务。 dispatch_group_wait 暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。 /** * 队列组 dispatch_group_wait */ - (void)groupWait { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程 NSLog(@"group---begin"); // 1. 创建group dispatch_group_t group = dispatch_group_create(); // 2. 异步执行组中全局队列任务 dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任务1 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程 } }); dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{ // 追加任务2 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程 } }); // 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程） dispatch_group_wait(group, DISPATCH_TIME_FOREVER); NSLog(@"group---end"); } ------------------输出结果：------------------ currentThread---{number = 1, name = main} group---begin 2---{number = 4, name = (null)} 1---{number = 3, name = (null)} 2---{number = 4, name = (null)} 1---{number = 3, name = (null)} group---end ------------------输出结果：------------------ 从dispatch_group_wait相关代码运行输出结果可以看出： 当所有任务执行完成之后，才执行 dispatch_group_wait 之后的操作。但是，使用dispatch_group_wait 会阻塞当前线程。 dispatch_group_enter、dispatch_group_leave dispatch_group_enter 标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1 dispatch_group_leave 标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。 当 group 中未执行完毕任务数为0的时候，才会使dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。 /** * 队列组 dispatch_group_enter、dispatch_group_leave */ - (void)groupEnterAndLeave { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程 NSLog(@"group---begin"); // 1.创建 group dispatch_group_t group = dispatch_group_create(); // 2. 获取全局并发队列 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // 3. 进入 group 中执行 dispatch_group_enter(group); // 3.1. 向队列中异步执行任务 dispatch_async(queue, ^{ // 追加任务1 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程 } // 3.2. 任务执行之后，离开组【leave 和 enter 必须成对使用】 dispatch_group_leave(group); }); // 4. 再次进入组执行新的任务 dispatch_group_enter(group); // 4.1. 向队列中异步执行任务 dispatch_async(queue, ^{ // 追加任务2 for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程 } // 4.2. 任务执行之后，离开组【leave 和 enter 必须成对使用】 dispatch_group_leave(group); }); // group 内部的任务都执行完之后通知执行下面代码 dispatch_group_notify(group, dispatch_get_main_queue(), ^{ // 等前面的异步操作都执行完毕后，回到主线程. for(inti = 0; i < 2; ++i) { [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程 } NSLog(@"group---end"); }); } -------------------输出结果------------------ currentThread---{number = 1, name = main} group---begin 1---{number = 4, name = (null)} 2---{number = 3, name = (null)} 1---{number = 4, name = (null)} 2---{number = 3, name = (null)} 3---{number = 1, name = main} 3---{number = 1, name = main} group---end -------------------输出结果------------------ 从dispatch_group_enter、dispatch_group_leave相关代码运行结果中可以看出：当所有任务执行完成之后，才执行 dispatch_group_notify 中的任务。这里的dispatch_group_enter、dispatch_group_leave组合，其实等同于dispatch_group_async。 GCD 信号量：dispatch_semaphore GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。类似于过高速路收费站的栏杆。可以通过时，打开栏杆，不可以通过时，关闭栏杆。在 Dispatch Semaphore 中，使用计数来完成这个功能，计数为0时等待，不可通过。计数为1或大于1时，计数减1且不等待，可通过。Dispatch Semaphore 提供了三个函数。 dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量 dispatch_semaphore_signal：发送一个信号，让信号总量加1 dispatch_semaphore_wait：可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。 注意：信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量。 Dispatch Semaphore 在实际开发中主要用于： 保持线程同步，将异步执行任务转换为同步执行任务 保证线程安全，为线程加锁 Dispatch Semaphore 线程同步 我们在开发中，会遇到这样的需求：异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将将异步执行任务转换为同步执行任务。比如说：AFNetworking 中 AFURLSessionManager.m 里面的 tasksForKeyPath: 方法。通过引入信号量的方式，等待异步执行任务结果，获取到 tasks，然后再返回该 tasks。 - (NSArray *)tasksForKeyPath:(NSString *)keyPath { __block NSArray *tasks = nil; dispatch_semaphore_t semaphore = dispatch_semaphore_create(0); [self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) { if([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) { tasks = dataTasks; } else if([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) { tasks = uploadTasks; } else if([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) { tasks = downloadTasks; } else if([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) { tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"]; } dispatch_semaphore_signal(semaphore); }]; dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); return tasks; } 下面，我们来利用 Dispatch Semaphore 实现线程同步，将异步执行任务转换为同步执行任务。 /** * semaphore 线程同步 */ - (void)semaphoreSync { NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程 NSLog(@"semaphore---begin"); dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_semaphore_t semaphore = dispatch_semaphore_create(0); __block int number = 0; dispatch_async(queue, ^{ // 追加任务1 [NSThread sleepForTimeInterval:2]; // 模拟耗时操作 NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程 number = 100; dispatch_semaphore_signal(semaphore); }); dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER); NSLog(@"semaphore---end,number = %zd",number); } ----------------------输出结果----------------- currentThread---{number = 1, name = main} semaphore---begin 1---{number = 3, name = (null)} semaphore---end, number = 100 从 Dispatch Semaphore 实现线程同步的代码可以看到： semaphore---end 是在执行完number = 100; 之后才打印的。而且输出结果 number 为 100。这是因为异步执行不会做任何等待，可以继续执行任务。异步执行将任务1追加到队列之后，不做等待，接着执行dispatch_semaphore_wait方法。此时 semaphore == 0，当前线程进入等待状态。然后，异步任务1开始执行。任务1执行到dispatch_semaphore_signal之后，总信号量加1，此时 semaphore == 1，dispatch_semaphore_wait方法检测到总信号量为1，正在被阻塞的线程（主线程）恢复继续执行。最后打印semaphore---en