1、GCD简介

• 全称是 Grand Central Dispatch;
• 纯 C 语言，提供了非常多强大的函数;
• GCD是非常高效的多线程开发方式，它并不是Cocoa框架的一部分

1.1 GCD优势

• GCD 是苹果公司为多核的并行运算提出的解决方案；
• GCD 会自动利用更多的CPU内核(比如双核、四核)
• GCD 会自动管理线程的生命周期(创建线程、调度任务、销毁线程)

总结：将任务添加到队列，并且指定执行任务的函数。

1.2 GCD函数

• 同步函数
  • 通过dispatch_sync(queue , {})获取;
  • 必须等待当前语句执行完毕，才会执行下一条语句;
  • 不会开启其他线程，就在当前线程中完成任务；
• 异步函数
  • 通过dispatch_async(queue , {})获取;
  • 不用等待当前语句执行完毕，就可以执行下一条语句
  • 会开启线程,异步就是多线程的代名词；

1.3 GCD队列

• 主队列
  • 通过dispatch_get_main_queue()获取;
  • 专⻔用来在主线程上调度任务的串行队列;
• 全局并发队列
  • 为了方便程序员的使用，苹果提供了全局队列dispatch_get_global_queue(0, 0)
  • 全局队列是并发队列,包含四个优先级；
• 自定义队列
  • 通过dispatch_queue_create("Lable", NULL);获取
  • 根据参数不同可以获取串行队列、并发队列；

1.3.1 串行队列

1.3.2 并发队列

2、GCD的使用

2.1 创建

• 同步函数

dispatch_sync(dispatch_get_main_queue();, ^{ });

• 异步函数

dispatch_async(dispatch_get_main_queue();, ^{ });

• 主队列

dispatch_get_main_queue();

• 全局并发队列

dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);

//全局并发队列的优先级
#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高优先级
#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）优先级
#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低优先级
#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台优先级

• 自定义队列

// 串行队列
dispatch_queue_create("HRTest", DISPATCH_QUEUE_SERIAL);
// 并发队列
dispatch_queue_create("HRTest", DISPATCH_QUEUE_CONCURRENT);

2.2 串行队列同步函数

-(void)demo{
    dispatch_queue_t queue = dispatch_queue_create("HRTest", NULL);
    dispatch_sync(queue, ^{
        NSLog(@"2");
    });
}

• 不会开启新的线程，在当前主线程下进行任务消耗；

这种搭配下很容易出现死锁情况

-(void)demo{
    dispatch_queue_t queue = dispatch_queue_create("HRTest", NULL);
    dispatch_sync(queue, ^{
        dispatch_sync(queue, ^{
            NSLog(@"1");
        });
        NSLog(@"2");
    });
}

• 执行结果看起来像：1 2，但事实会出现死锁；

  • 任务一执行依赖任务三，任务三依赖任务二，任务二又依赖任务一；形成一个循环没有出口；

2.3 串行队列异步函数

-(void)demo{
    NSLog(@"%@",[NSThread currentThread]);
    dispatch_queue_t queue = dispatch_queue_create("HRTest", NULL);
    for (int i = 0; i<3; i++) {
        dispatch_async(queue, ^{
            NSLog(@"1- %@",[NSThread currentThread]);
        });
    }
    for (int i = 0; i<3; i++) {
        dispatch_async(queue, ^{
            NSLog(@"2- %@",[NSThread currentThread]);
        });
    }
    for (int i = 0; i<3; i++) {
        dispatch_async(queue, ^{
            NSLog(@"3- %@",[NSThread currentThread]);
        });
    }
}

输出：

• 异步函数串行队列导致只会开启一条新的线程；

这种搭配下也会出现死锁情况

-(void)demo{
    NSLog(@"%@",[NSThread currentThread]);
    dispatch_queue_t queue = dispatch_queue_create("HRTest", NULL);
    dispatch_async(queue, ^{
        NSLog(@"2");
        dispatch_sync(queue, ^{
            NSLog(@"3");
        });
    });
}

• 这种情况下也会产生死锁，任务二（同步函数）和任务三（同步函数需要执行的block）相互等待；

总体来说涉及到串行队列的嵌套就容易出现死锁，使用时一定要注意；串行队列里添加同步任务队列必定会出现死锁；

2.3 并发队列同步函数

-(void)demo{
    dispatch_queue_t queue = dispatch_queue_create("cooci", DISPATCH_QUEUE_CONCURRENT);
    // 耗时
    dispatch_sync(queue, ^{
        NSLog(@"%@",[NSThread currentThread]);
        NSLog(@"2");
        dispatch_sync(queue, ^{
            NSLog(@"%@",[NSThread currentThread]);
            NSLog(@"3");
        });
        NSLog(@"4");
    });
}

输出：

• 虽然是并发队列但是因为是同步函数,所以不会开启新的线程，在当前主线程下进行任务消耗；

2.4 并发函数异步队列

-(void)demo{
    dispatch_queue_t queue = dispatch_queue_create("cooci", DISPATCH_QUEUE_CONCURRENT);
   // 耗时
   dispatch_async(queue, ^{
       NSLog(@"%@",[NSThread currentThread]);
       NSLog(@"1");
       dispatch_async(queue, ^{
           NSLog(@"%@",[NSThread currentThread]);
           NSLog(@"2");
       });
       NSLog(@"3");
   });
}

输出：

• 会产生多条线程；

2.5 GCD线程间通信

// 异步
dispatch_async(dispatch_get_global_queue(0, 0), ^{
    // 耗时操作放在这里
    [NSThread sleepForTimeInterval:2];

    // 回到主线程处理UI
    dispatch_async(dispatch_get_main_queue(), ^{
        self.imageView.image = image;
    });
});

2.6 GCD延时执行

-(void)demo{
    NSLog(@"%@",[NSDate date]);
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%@",[NSDate date]);
    });
}

输出：

2.7 GCD栅栏

dispatch_queue_t queue = dispatch_queue_create("HRTest", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue1, ^{
    NSLog(@"1");
});
dispatch_async(queue1, ^{
    NSLog(@"2");
});

dispatch_barrier_async(queue1, ^{
    NSLog(@"3");
});
dispatch_async(queue1, ^{
    NSLog(@"4");
});

• 1 2 一定在3前面执行，4一定在3后面执行；

2.8 GCD队列组

队列组有下面几个特点：

• 所有的任务会并发的执行(不按序)。
• 所有的异步函数都添加到队列中，然后再纳入队列组的监听范围。
• 使用dispatch_group_notify函数，来监听上面的任务是否完成，如果完成, 就会调用这个方法。

-(void)demo{
    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    //创建一个队列组
    dispatch_group_t group = dispatch_group_create();
    
    dispatch_group_async(group, queue, ^{
        NSLog(@"下载1开始");
        [NSThread sleepForTimeInterval:2];
        NSLog(@"下载1结束");
    });
    dispatch_group_async(group, queue, ^{
        NSLog(@"下载2开始");
        [NSThread sleepForTimeInterval:2];
        NSLog(@"下载2结束");
    });
    
    dispatch_group_notify(group, queue, ^{
        NSLog(@"下载全部结束");
        //在主线程显示
        dispatch_async(dispatch_get_main_queue(), ^{
            self.imageView.image = image;
        });
    });
}

2.9 GCD信号量

// 创建一个信号，value：信号量
dispatch_semaphore_create(<#long value#>)
// 使某个信号的信号量+1
dispatch_semaphore_signal(<#dispatch_semaphore_t dsema#>)
// 某个信号进行等待或等待降低信号量 timeout：等待时间，永远等待为 DISPATCH_TIME_FOREVER
dispatch_semaphore_wait(<#dispatch_semaphore_t dsema#>, <#dispatch_time_t timeout#>)

• 正常的使用顺序是先降低然后再提高，这两个函数通常成对使用`。
• 信号量代表可以进入的线程数，信号量为0表示当前线程堵塞;

2.10 单例

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[self alloc] init];
    });