将任务添加到队列，并且指定执行任务的函数。
在GCD当中只考虑队列和任务的关系就好，不要考虑线程。不然会晕哦

一、GCD的概念

1、全称是 Grand Central Dispatch
2、纯 C 语言，提供了非常多强大的函数
3、GCD 是苹果公司为多核的并行运算提出的解决方案
4、GCD 会自动利用更多的CPU内核（比如双核、四核）
5、GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
6、程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码
7、将任务加入到队列当中

二、函数

1、将任务添加到队列，并且指定执行任务的函数
2、任务使用 block 封装
3、任务的 block 没有参数也没有返回值
4、执行任务的函数

4.1异步 dispatch_async

4.1.1 不用等待当前语句执行完毕，就可以执行下一条语句
4.1.2 会开启线程执行 block 的任务
4.1.3 异步是多线程的代名词

4.2同步 dispatch_sync

4.2.1 必须等待当前语句执行完毕，才会执行下一条语句
4.2.2 不会开启线程
4.2.3 在当前线程执行 block 的任务

三、队列

队列.png

1. 并发

DISPATCH_QUEUE_CONCURRENT

2. 串行

DISPATCH_QUEUE_SERIAL

3. 主队列

3.1 专门用来在主线程上调度任务的队列
3.2 不会开启线程
3.3 如果当前主线程正在有任务执行，那么无论主队列中当前被添加了什么任务，都不会被调度
3.4 dispatch_get_main_queue();

4. 全局队列

4.1 为了方便程序员的使用，苹果提供了全局队列 dispatch_get_global_queue(0, 0)
4.2 全局队列是一个并发队列
4.3 在使用多线程开发时，如果对队列没有特殊需求，在执行异步任务时，可以直接使用全局队列

四、函数与队列

异步会开启线程，同步不会开启线程
同步会堵塞，堵塞的是block里面的代码执行完毕，block的}。必须等待当前语句执行完毕，才会执行下一条语句
开不开启线程只和同步异步有关，和队列是串行还是并行无关
堵不堵塞只和同步异步有关，和队列是串行还是并行无关
异步、同步都会耗时，但是异步比同步更耗时

1. 同步函数串行队列

不会开启线程，在当前线程执行任务
任务串行执行，任务一个接着一个
会产生堵塞

2. 同步函数并发队列

不会开启线程，在当前线程执行任务
任务一个接着一个

异步函数串行队列

开启线程一条新线程
任务一个接着一个

异步函数并发队列

开启线程，在当前线程执行任务
任务异步执行，没有顺序，CPU调度有关

五、死锁

主队列同步任务，死锁。FIFO，抢着去执行然后卡住了。（dyz）
主线程因为你同步函数的原因等着先执行任务，主队列等着主线程的任务执行完毕再执行自己的任务，主队列和主线程相互等待会造成死锁

六、应用

1. 单利 dispatch_once

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        <#code to be executed once#>
    });

2. 延迟 dispatch_after

异步的

//NSEC_PER_SEC : 1000000000ull 纳秒每秒
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        <#code to be executed after a specified delay#>
    });

3. 信号量

锁/控制并发数 dispatch_semaphore_t

dispatch_semaphore_create 创建信号量
dispatch_semaphore_wait 信号量等待
dispatch_semaphore_signal 信号量释放

同步当锁, 控制GCD最大并发数

   dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
     // 信号量 -- gcd控制并发数
     dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

     //任务1
     dispatch_async(queue, ^{
         dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
         NSLog(@"执行任务1");
         sleep(1);
         NSLog(@"任务1");
         sleep(1);
         NSLog(@"任务1完成");
         dispatch_semaphore_signal(semaphore);
     });

     //任务2
     dispatch_async(queue, ^{
         dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
         NSLog(@"执行任务2");
         sleep(1);
         NSLog(@"任务2");
         sleep(1);
         NSLog(@"任务2完成");
         dispatch_semaphore_signal(semaphore);
     });

     //任务3
     dispatch_async(queue, ^{
         dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
         NSLog(@"执行任务3");
         sleep(1);
         NSLog(@"任务3");
         sleep(1);
         NSLog(@"任务3完成");
         dispatch_semaphore_signal(semaphore);
     });

如果需要当锁卡住的话，必须设置为0 dispatch_semaphore_create(0)

4. 栅栏函数

最直接的作用: 控制任务执行顺序,同步

dispatch_barrier_async 前面的任务执行完毕才会来到这里
dispatch_barrier_sync 作用相同,但是这个会堵塞线程,影响后面的任务执行
非常重要的一点: 栅栏函数只能控制同一并发队列

控制执行顺序有不足
注意自定义并发队列
4.1 保证顺序执行
4.2 保证线程安全

注意

一定要是自定义的并发队列
必须要求都在同一个队列
不利于封装
不是非常优秀

    dispatch_queue_t concurrentQueue = dispatch_queue_create("cc", DISPATCH_QUEUE_CONCURRENT);
    
    /* 1.异步函数 */
    dispatch_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"download1-%zd-%@",i,[NSThread currentThread]);
        }
    });

    dispatch_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"download2-%zd-%@",i,[NSThread currentThread]);
        }
    });
    
    /* 2. 栅栏函数 */
    dispatch_barrier_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"---------------------%@------------------------",[NSThread currentThread]);
        }
    });
    
    NSLog(@"加载那么多,喘口气!!!");
    
    
    /* 3. 异步函数 */
    dispatch_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"日常处理3-%zd-%@",i,[NSThread currentThread]);
        }
    });
    
    NSLog(@"************起来干!!");
    
    dispatch_async(concurrentQueue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"日常处理4-%zd-%@",i,[NSThread currentThread]);
        }
    });

5. 调度组

最直接的作用: 控制任务执行顺序，不必要求队列是同一个队列
>创建组:dispatch_group_create
进组任务:dispatch_group_async
进组任务执行完毕通知: dispatch_group_notify
进组任务执行等待时间:dispatch_group_wait
进组: dispatch_group_enter
出组: dispatch_group_leave
控制执行顺序

实例一
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"第一个走完了");
        dispatch_group_leave(group);
    });
    
    dispatch_group_enter(group);
    dispatch_async(queue, ^{
        NSLog(@"第二个走完了");
        dispatch_group_leave(group);
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        NSLog(@"所有任务完成,可以更新UI");
    });

实例二
    //创建调度组
    dispatch_group_t group = dispatch_group_create();
    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);
    dispatch_queue_t queue1 = dispatch_queue_create("com.lg.cn", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_group_async(group, queue, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"download1-%zd-%@",i,[NSThread currentThread]);
        }
    });
    
    dispatch_group_async(group, queue1, ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"download2-%zd-%@",i,[NSThread currentThread]);
        }
    });

    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        for (NSUInteger i = 0; i < 5; i++) {
            NSLog(@"---------------------%@------------------------",[NSThread currentThread]);
        }
    });

6. Dispatch_source

>创建源：dispatch_source_create
>设置源事件回调：dispatch_source_set_event_handler
源事件设置数据：dispatch_source_merge_data
获取源事件数据：dispatch_source_get_data
继续：dispatch_resume
挂起：dispatch_suspend

    self.source = dispatch_source_create(DISPATCH_SOURCE_TYPE_DATA_ADD, 0, 0, dispatch_get_main_queue());
    dispatch_source_set_event_handler(self.source, ^{
        NSInteger value = dispatch_source_get_data(self.source);
        NSLog(@"%ld",(long)value);
    });
    dispatch_resume(self.source);

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    dispatch_source_merge_data(self.source, 4);// 传0，不会有回调，why？
}

7. timer

    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, <#dispatchQueue#>);
    dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, <#intervalInSeconds#> * NSEC_PER_SEC, <#leewayInSeconds#> * NSEC_PER_SEC);
    dispatch_source_set_event_handler(timer, ^{
        <#code to be executed when timer fires#>
    });
    dispatch_resume(timer);

必须用一个全局变量接收一下，否则被释放了没法执行定时器。这个定时器都不需要你释放，自动释放，太牛逼了。传入的是什么线程，相应的就是什么线程。可以用MLeaksFinder检测。

延迟5秒执行（必须是 5 * NSEC_PER_SEC，不能单独是5哦）： DISPATCH_TIME_NOW 换成 dispatch_time(DISPATCH_TIME_NOW, 5 * NSEC_PER_SEC)

@property (nonatomic, strong) dispatch_source_t source;

    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_global_queue(0, 0));
    dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC, 0);
    dispatch_source_set_event_handler(timer, ^{
        NSLog(@"----%@",[NSThread currentThread]);//子线程 滑动UI不会卡顿
    });
    dispatch_resume(timer);
    self.source = timer;

多线程二之GCD