1.GCD优点：
1.可以自动合理地利用更多的CPU内核。
2.会自动管理线程的生命周期（创建线程，调度任务，销毁线程），完全不需要我们管理线程
2.任务和队列
在多线程中，必须先了解两个概念：任务和队列
任务：是你需要做的事情，任务的执行方式总共有两种：同步执行和异步执行，区别在于是否会在新创建的线程中执行，也就是说会不会阻塞当前的线程。
● 同步执行：在当前的线程中执行，阻塞当前线程直到block中的任务执行完成，当前线程才会继续执行下面的代码
● 异步执行：会在新的线程里执行任务，当前线程会往下执行，不会阻塞线程
队列：队列是任务的队列，是储存任务的，一共有两种方式：串行队列 和 并行队列
● 串行队列：FIFO的执行顺序，先进先出，从队列中取出来一个，执行一个，执行完毕后，然后取出下一个，来执行。
● 并行队列：从队列中取出一个，放在一个新线程里，再去取一个，放在另一个新的线程里，因为取出的时间很短，所以可以认为，每一个任务都放在了一个线程里执行，值得注意的是，系统为了控制资源，会控制并行线程的数量，不会让所有的任务同时执行的。
所以，我们可以总结出六种情况
● 串行队列，同步执行： 在当前线程，任务一个一个执行，任务是添加到队列里马上执行的。
● 串行队列，异步执行： 在新创建的线程，任务一个一个来执行，任务是添加到队列里并不是马上执行，而是等到将所有任务都添加到队列以后才开始同步执行。
● 并行队列，同步执行： 在当前线程，任务一个一个来执行，任务是添加到队列里马上执行的。
● 并行队列，异步执行： 创建很多新线程，任务几乎同一时间来执行，任务是添加到队列里并不是马上执行，而是等到将所有任务都添加到队列以后才开始异步执行。
● 主队列，同步执行：卡死，不可行
● 主队列，异步执行：在主线程，一个一个来执行，任务是添加到队列里并不是马上执行，而是等到将所有任务都添加到队列以后才开始同步执行。
3.队列创建的方式
● 可以更加 dispatch_queue_t 来创建一个队列，dispatch_queue_create 有两个参数，第一个是队列的唯一标识符，可以不填，第二个比较重要，标识是串行队列还是并行队列。
DISPATCH_QUEUE_SERIAL 或 NULL 表示创建串行队列
DISPATCH_QUEUE_CONCURRENT 表示创建并行队列。
dispatch_queue_t queue = dispatch_get_main_queue(); //主线程队列
dispatch_queue_t queue = dispatch_queue_create("xq_test", DISPATCH_QUEUE_SERIAL); //串行队列
dispatch_queue_t queue = dispatch_queue_create("xq_test", NULL); //串行队列
dispatch_queue_t queue = dispatch_queue_create("xq_test", DISPATCH_QUEUE_CONCURRENT);//并行队列
● 全局并行队列，这是系统提供的一个并发队列。只要是并行任务一般都加入到这个队列。 dispatch_get_global_queue 来创建全局并行队列： dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
});
4.任务创建的方式
● 同步任务：sync
dispatch_sync(queue, ^{
});
● 异步任务：async
dispatch_async(queue, ^{
});
5.GCD其他用法
● GCD的延时方法 dispatch_after
dispatch_time_t popTime = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(1.0f * NSEC_PER_SEC));
dispatch_after(popTime, dispatch_get_main_queue(), ^(void){
});
● dispatch_once 只执行一次 单利模式
+ (nonnull instancetype)sharedManager {
static dispatch_once_t once;
static id instance;
dispatch_once(&once, ^{
instance = [self new];
});
return instance;
}
● dispatch_apply 快速遍历方法,取出多个数字进行遍历
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_apply(10, queue, ^(size_t) {
});
● 回到主线程
dispatch_async(dispatch_get_main_queue(), ^{
});
● dispatch_barrier_sync和 dispatch_barrier_async
作用：等待在它前面插入队列的任务先执行完,等待他们自己的任务执行完再执行后面的任务
区别： dispatch_barrier_sync将自己的任务插入到队列的时候，需要等待自己的任务结束之后才会继续插入被写在它后面的任务，然后执行它们 2.dispatch_barrier_async将自己的任务插入到队列之后，不会等待自己的任务结束，它会继续把后面的任务插入到队列，然后等待自己的任务结束后才执行后面任务。
- (void)dispatchBarrier
{
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_async(queue, ^{
NSLog(@"A-%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"B-%@", [NSThread currentThread]);
});
dispatch_barrier_async(queue, ^{
NSLog(@"dispatchBarrier-%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"C-%@", [NSThread currentThread]);
});
dispatch_async(queue, ^{
NSLog(@"D-%@", [NSThread currentThread]);
});
}
结果表明：A,B执行完以后，才会执行 C,D
● dispatch_group 队列组，作用是：使用dispatch_group来进行线程同步
（1）dispatch_group_async
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
//执行完成
});
(2) dispatch_group_enter(group)、dispatch_group_leave(group) ，dispatch_group_wait,手动管理group关联的block的运行状态（或计数），进入和退出group次数必须匹配
//1.创建任务组
dispatch_group_t group = dispatch_group_create();
//2.第一个任务
dispatch_group_enter(group);
dispatch_group_leave(group);
//3.第二个任务
dispatch_group_enter(group);
dispatch_group_leave(group);
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"所有任务组都完成了");
});
1)
dispatch_group_async(group, queue, ^{
});
2)
dispatch_group_enter(group);
dispatch_async(queue, ^{
dispatch_group_leave(group);
});
1和2的两种调用是等价的，只不过使用的方法不同而已
dispatch_group_wait(group, DISPATCH_TIME_FOREVER); 等待线程同步完成
这是stackoverflow的一个例子
dispatch_group_t group = dispatch_group_create();
MyCoreDataObject *coreDataObject;
dispatch_group_enter(group);
AFHTTPRequestOperation *operation1 = [[AFHTTPRequestOperation alloc] initWithRequest:request1];
[operation1 setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
coreDataObject.attribute1 = responseObject;
sleep(5);
dispatch_group_leave(group);
}];
[operation1 start];
dispatch_group_enter(group);
AFHTTPRequestOperation *operation2 = [[AFHTTPRequestOperation alloc] initWithRequest:request1];
[operation2 setCompletionBlockWithSuccess:^(AFHTTPRequestOperation *operation, id responseObject) {
coreDataObject.attribute2 = responseObject;
sleep(10);
dispatch_group_leave(group);
}];
[operation2 start];
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
dispatch_release(group);
[context save:nil];
