多线程之GCD

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];