GCD整理（二）
这篇会整理GCD常用的API
目录
1、dispatch_after
2、dispatch_apply
3、dispatch_barrier_async
4、Dispatch Semaphore
5、Dispatch Group
dispatch_after
看下面一段代码：
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);
dispatch_after(time, dispatch_get_main_queue(), ^{
NSLog(@"hey");
});
dispatch_time_t类型变量作为dispatch_after函数的第一个参数，可以由dispatch_time和dispatch_walltime函数创建。先来说前者。
dispatch_time函数接收两个参数，它会返回从第一个参数指定的时间开始，到第二个参数指定的以毫微秒为单位的时间间隔后的时间。比如上面代码中就是从现在开始，3秒后的时间。
dispatch_after会将任务在指定时间后加入到执行队列，n * NSEC_PER_SEC会得到一个单位是毫微秒的数值，要表达3秒需要写成3 * NSEC_PER_SEC，直接写3是不行的。如果需要表示毫秒，可以使用NSEC_PER_MSEC，比如100毫秒写成100 * NSEC_PER_MSEC。
dispatch_walltime用于指定绝对时间，比如要指定时间为2011年11月11日11时11分11秒，可以使用如下方法做NSDate到dispatch_time_t的转换。
+ (dispatch_time_t)getDispatchTimeByDate:(NSDate *)date{
NSTimeInterval interval;
CGFloat second, subsecond;
struct timespec time;
dispatch_time_t milestone;
interval = [date timeIntervalSince1970];
subsecond = modf(interval, &second);
time.tv_sec = second;
time.tv_nsec = subsecond * NSEC_PER_SEC;
milestone = dispatch_walltime(&time, 0);
return milestone;
}
关于dispatch_after方法的参数：
dispatch_after(dispatch_time_t when, dispatch_queue_t queue, dispatch_block_t block) 参数1：执行的时间。参数2：执行的队列。参数3：任务。
另外，因为dispatch_after并不是在指定时间后执行，而是指定时间后加入队列，所示任务执行的具体时间未必会准确按照time参数。
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 0.5 * NSEC_PER_SEC);
int i = 1;
while (i < 1000000000) {
i++;
}
dispatch_after(time, dispatch_get_main_queue(), ^{
NSLog(@"hey");
});
比如这段代码，因为循环和log都在主线程执行，循环会执行很久，所以0.5秒后输出语句并没有执行，只是加入到队列中，等到循环结束才输出“hey”。
如果只是简单的使用可以直接使用系统提供的代码块来快速生成代码。
dispatch_after代码块.png
dispatch_apply
dispatch_apply会按照给定的次数在指定队列中重复执行任务，注意它是dispatch_sync和Dispatch Group的关联API，为什么要注意这个等下就会看到。
NSArray *arr = @[@"1", @"2", @"3", @"4", @"5", @"6", @"7", @"8", @"9"];
dispatch_apply(arr.count, dispatch_get_main_queue(), ^(size_t index) {
NSLog(@"---%@", arr[index]);
});
在主线程中运行这段代码，会发现不会有任何输出并且程序也会卡死，没错死锁了。dispatch_apply函数和dispatch_sync相同，都会等待任务执行结束，也就意味着dispatch_apply也是一个同步方法。在死锁的判断中，可以把它理解为一个sync函数，这样就明白为什么这里会发生死锁了(关于死锁的问题在GCD整理(一))。
另外如果dispatch_apply函数指定了串行队列作为参数，那么遍历会按照顺序执行，如果是并发队列，执行顺序则不受控制。因为串行队列只对应一条线程，并发队列会对应多个线程。
代码和效果如下：
NSArray *arr = @[@"1", @"2", @"3", @"4", @"5", @"6", @"7", @"8", @"9"];
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
dispatch_apply(arr.count, queue, ^(size_t index) {
NSLog(@"---%@", arr[index]);
});
dispatch_apply串行队列.png
NSArray *arr = @[@"1", @"2", @"3", @"4", @"5", @"6", @"7", @"8", @"9"];
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_apply(arr.count, queue, ^(size_t index) {
NSLog(@"---%@", arr[index]);
});
dispatch_apply并行队列.png
dispatch_barrier_async
提供这样一种功能，它将dispatch_barrier_async函数之前加入队列的任务和dispatch_barrier_async之后加入队列的任务分割开。并且dispatch_barrier_async的block会等待前面的任务执行完成后在执行，同时block执行完成之前即使是并发队列后面的任务也不会执行。
dispatch_barrier_async执行逻辑.png
一个典型的例子是使用dispatch_barrier_async处理读写问题，在读写数据库表的操作中，如果单纯的使用dispatch_async函数执行写操作并且并发队列中存在多个写任务，那么写入的数据很有可能是错误的。我们只希望同一时间只有一个任务在操作表。
另外一个情况，当任务1-2要执行读取，读取后任务3要进行写入，写入完成后任务4再次读取拿到新写入的数据。这样的情况使用dispatch_barrier_async就会很方便。
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
NSLog(@"read1");
});
dispatch_async(queue, ^{
NSLog(@"read2");
});
dispatch_barrier_async(queue, ^{
NSLog(@"write");
});
dispatch_async(queue, ^{
NSLog(@"read4");
});
Dispatch Semaphore
信号量的作用和dispatch_barrier_async有些类似，它可以更加细致的控制数据的线程安全性。
描述信号量的概念可以生动的用厕所来比喻，初始值为1的信号量就像只有一个坑的厕所，初始值为2就是两个坑的厕所。每当进去一个人就会把门锁上，信号量就减1；出来的时候自然会把门打开，信号量就加1。如果厕所所有的坑都被占了，后面来的人就只能等待。
可以用下面的语法创建一个信号量：
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
dispatch_semaphore_create接受一个长整形参数，这段代码就好比创建了一个只有一个坑的厕所。可以用下面的语句来描述一个人占据了一个坑位的情况。
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC);
dispatch_semaphore_wait(semaphore, time);
dispatch_semaphore_wait接受两个参数，参数1：对应的信号量。参数2：超时时间。这个函数有一个长整形返回值，返回值为0表示信号量的值大于等于1，或者在指定的等待时间内，超时返回非0。
引用一段别人对该函数的描述。
如果信号量的值大于0，该函数所处线程就继续执行下面的语句，并且将信号量的值减1；如果信号量的值为0，那么这个函数就阻塞当前线程等待timeout，如果等待的期间信号量的值被dispatch_semaphore_signal函数加1了，且该函数（即dispatch_semaphore_wait）所处线程获得了信号量，那么就继续向下执行并将信号量减1。如果等待期间没有获取到信号量或者信号量的值一直为0，那么等到timeout时，其所处线程自动执行其后语句。参考链接
有减就一定有加，dispatch_semaphore_signal就是对应从厕所开门出来那段剧情的函数。这个函数会把传入的信号量加1，它同样有返回值，0代表当前并没有等待中的线程需要被唤醒；非0代表当前有至少一个等待中的线程，并且成功唤醒了其中一个。
运行一段代码看下效果：
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3 * NSEC_PER_SEC);
for (NSInteger i = 0; i < 3; i++) {
dispatch_async(queue, ^{
NSInteger wait = dispatch_semaphore_wait(semaphore, time);
NSLog(@"wait:%ld-%@", wait, [NSThread currentThread]);
int i = 1;
while (i < 1000000000) {
i++;
}
NSLog(@"finish");
NSInteger singal = dispatch_semaphore_signal(semaphore);
NSLog(@"singal:%ld-%@", singal, [NSThread currentThread]);
});
}
dispatch_semaphore运行结果.png
分析代码的运行逻辑：number=2的线程最先拿到了信号量，并将信号量减1，与此同时3、4线程也运行到了这里并且开始等待。在等待过程中2线程将循环执行完毕并调用dispatch_semaphore_signal函数，dispatch_semaphore_signal发现还有两个线程在等待中，有线程在等待就返回非0(这里为1)；同时线程3开始拿到信号量并执行循环。这时候指定的等待时间3秒已经到了，线程4不能再等了，于是开始执行循环。这就意味着线程3和4在某一段时间内是同时执行循环操作的。随后各自执行dispatch_semaphore_signal函数，此时已经没有等待线程存在所以返回0。
再放一个例子：
NSMutableArray *array = [[NSMutableArray alloc] init];
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);
for (NSInteger i = 0; i < 1000; i++) {
dispatch_async(queue, ^{
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
[array addObject:@(i)];
dispatch_semaphore_signal(semaphore);
});
}
因为NSMutableArray是非线程安全的，如果同一时间有多个线程对array数组进行addObject操作一定会发生异常。可以使用信号量来控制同一时间只有一条线程执行addObject操作。
Dispatch Group
Dispatch Group 可以处理这样一种情况：一个或多个并发队列中有很多任务在执行，而有一个任务必须在所有任务都执行完成后最后执行。比如要上传多张图片到后台，在全部上传完成后要告知用户图片上传完成。
这时Dispatch Group就会发挥极大的作用：
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue1 = dispatch_queue_create("queue1", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t queue2 = dispatch_queue_create("queue2", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_async(group, queue1, ^{
NSLog(@"queue1 hello:%@", [NSThread currentThread]);
});
dispatch_group_async(group, queue1, ^{
NSLog(@"queue1 world:%@", [NSThread currentThread]);
});
dispatch_group_async(group, queue2, ^{
NSLog(@"queue2 hello:%@", [NSThread currentThread]);
});
dispatch_group_async(group, queue2, ^{
NSLog(@"queue2 world:%@", [NSThread currentThread]);
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"finish:%@", [NSThread currentThread]);
});
dispatch_group_create函数用来创建一个 Dispatch Group。dispatch_group_async用法与dispatch_async一样，只是多了个group参数。dispatch_group_notify函数会在group里的block全部执行完成后运行自己的block。
Dispatch Group还有一个很重要的方法：
dispatch_group_wait(dispatch_group_t group, dispatch_time_t timeout); 指定Dispatch Group的等待时间。参数1：组。参数2：超时时间。函数有一个返回值，为0表示在指定时间内所有的block都已经执行完毕。非0表示在指定时间内任务没有执行完。
还有比较常见的Dispatch Once，用法比较简单也不整理了。
最后，这篇GCD整理是阅读《Objective-C高级编程 iOS与OS X多线程和内存管理》GCD部分的内容后，结合其他大大们的博文以及自己的理解整理的一份笔记。水平有限，欢迎指正。
