iOS GCD的基本使用
GCD在iOS中多线程开发中使用频繁，使用方便简单，可以满足我们大部分需求。其使用方法如下：
1、基本认识
GCD以任务队列为基础的多线程管理的方案，使用者不直接调用线程，而是调用队列，往队列中添加执行任务，决定任务的执行方式。
GCD中的队列分为串行队列、并行队列，执行方式分为同步执行、异步执行。
串行队列：每次只能执行一个任务，等待任务执行完毕才能执行第下一个任务。
并行队列：每次可以执行多个任务，后面的任务不依赖前面的任务执行情况。
同步执行：执行任务时，需要当前代码执行完毕才能执行后面的代码，会阻塞当前线程
异步执行：执行任务时，当前代码不会影响后续任务外的代码的执行，不会阻塞当前线程
创建方式如下：
self.serial_queue = dispatch_queue_create("串行队列", DISPATCH_QUEUE_SERIAL);
self.concurrent_queue = dispatch_queue_create("并行队列", DISPATCH_QUEUE_CONCURRENT);
其中队列名称可自行定义。
队列和执行方式有四种组合
a、串行队列，同步执行
任务按顺序在当前线程执行，并且会阻塞当前线程，代码如下：
- (void)sync_serial_queue {
for (int i = 0; i < 20; i++) {
dispatch_sync(self.serial_queue, ^{
NSLog(@"%d===%@",i,[NSThread currentThread]);
});
}
}
b、串行队列，异步执行
任务按顺序执行，不一定在当前线程，不会阻塞当前线程，代码如下：
- (void)async_serial_queue {
for (int i = 0; i < 20; i++) {
dispatch_async(self.serial_queue, ^{
NSLog(@"%d===%@",i,[NSThread currentThread]);
});
}
}
c、并行队列，同步执行
任务按顺序执行，不在当前线程，会阻塞当前线程，代码如下：
- (void)sync_concurrent_queue {
for (int i = 0; i < 20; i++) {
dispatch_sync(self.concurrent_queue, ^{
NSLog(@"%d===%@",i,[NSThread currentThread]);
});
}
}
d、并行队列，异步执行
任务不按顺序执行，不在当前线程，不会阻塞当前线程，代码如下：
- (void)async_concurrent_queue {
for (int i = 0; i < 20; i++) {
dispatch_async(self.concurrent_queue, ^{
NSLog(@"%d===%@",i,[NSThread currentThread]);
});
}
}
iOS的系统框架提供了两个系统级队列，分别为主队列和全局队列，特性如下：
主队列：串行队列，任务只在主线程执行
全局队列：并行队列，可设置优先级
队列获取代码如下：
//主队列
dispatch_queue_t main_queue = dispatch_get_main_queue();
//全局队列
dispatch_queue_t global_queue = dispatch_get_global_queue(0, 0);
在一般的需求下可以使用全局队列，在代码需要在主线程环境时使用主队列。
2、dispatch barrier的使用
当我们存在以下情况，任务4依赖于任务1、任务2、任务3的执行，任务5、任务6、任务7依赖于任务4的执行，其中任务1、任务2、任务3可以分别独立执行，任务5、任务6、任务7页可以分别独立同时执行，如下图：
图片.png
则可以使用dispatch_barrier，函数有dispatch_barrier_sync和dispatch_barrier_async，区别在于dispatch_barrier_sync会阻塞后续代码的运行，dispatch_barrier_async不会阻塞后续代码的运行。两个函数代码如下：
/**
异步并行队列，barrier同步，使barrier前面的任务全部执行完毕，才会执行barrier后面添加到queue的任务,barrier_sync会影响后阻塞后续代码的执行
*/
- (void)concurrent_queue_barier_sync {
NSLog(@"start");
for (int i = 0; i < 10; i++) {
dispatch_async(self.concurrent_queue, ^{
NSLog(@"%d===%@",i,[NSThread currentThread]);
});
if (i == 5) {
NSLog(@"barrier sync");
dispatch_barrier_sync(self.concurrent_queue, ^{
NSLog(@"dispatch_barrier_sync===%d===%@",i,[NSThread currentThread]);
});
}
}
NSLog(@"end");
}
/**
异步并行队列，barrier同步，使barrier前面的任务全部执行完毕，才会执行barrier后面添加到queue的任务，barrier_async不会影响后续代码的执行
*/
- (void)concurrent_queue_barier_async {
NSLog(@"start");
for (int i = 0; i < 10; i++) {
dispatch_async(self.concurrent_queue, ^{
NSLog(@"%d===%@",i,[NSThread currentThread]);
});
if (i == 5) {
NSLog(@"barrier async");
dispatch_barrier_async(self.concurrent_queue, ^{
NSLog(@"dispatch_barrier_async===%d===%@",i,[NSThread currentThread]);
});
}
}
NSLog(@"end");
}
3、延迟执行
当我们需要延迟执行某个任务，一般情况下我们可以使用dispatch_after函数，代码如下：
- (void)dispatch_after {
NSLog(@"%@",[NSDate date]);
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
NSLog(@"after == %@",[NSDate date]);
});
}
4、单次执行
当我们需要创建单例或者只需要代码在程序运行过程中只执行一次时，我们可以使用dispatch_once函数，代码如下：
- (void)dispatch_once {
for (int i = 0; i < 10; i++) {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
NSLog(@"%d",i);
});
}
}
5、多线程快速迭代
当我们的数组需要在多线程情况下遍历时可以使用dispatch_apply，使用较少，代码如下：
- (void)dispatch_apply {
dispatch_apply(10, self.concurrent_queue, ^(size_t index) {
NSLog(@"dispatch_apply==%zud===%@",index,[NSThread currentThread]);
});
}
6、多任务同步
当我们需要实现下面的任务时，除了第二项的dispatch_barrier，我们还可以使用dispatch_group。任务4依赖于任务1、任务2、任务3的执行，如下图：
图片.png
主要操作步骤：1、创建dispatch_group；2、把任务加入到group，等待任务执行完毕；3、任务执行完毕，调用dispatch_group_notify里面的任务。
第2步把任务加入到group中的操作有两种方法，一种是直接使用dispatch_group_async，另外一种是使用dispatch_group_enter、dispatch_group_leave两个函数，dispatch_group_enter表示进入group，dispatch_group_leave表示一个任务执行完毕，离开group。
我们也可以使用同步函数dispatch_group_wait来等待任务1、任务2、任务3执行完毕，然后执行dispatch_group_wait后面的代码。
代码如下：
- (void)dispatch_group_1 {
dispatch_group_t group_t = dispatch_group_create();
for (int i = 0; i < 10; i++) {
dispatch_group_async(group_t, self.concurrent_queue, ^{
NSLog(@"dispatch_group_1===%d===%@",i,[NSThread currentThread]);
});
}
dispatch_group_notify(group_t, dispatch_get_main_queue(), ^{
NSLog(@"转主线程");
});
}
- (void)dispatch_group_2 {
dispatch_group_t groutp_t = dispatch_group_create();
for (int i = 0; i < 10; i++) {
dispatch_group_enter(groutp_t);
dispatch_async(self.concurrent_queue, ^{
NSLog(@"dispatch_group_2===%d===%@",i,[NSThread currentThread]);
dispatch_group_leave(groutp_t);
});
}
dispatch_group_notify(groutp_t, dispatch_get_main_queue(), ^{
NSLog(@"转主线程");
});
}
- (void)dispatch_group_3 {
dispatch_group_t groutp_t = dispatch_group_create();
for (int i = 0; i < 10; i++) {
dispatch_group_enter(groutp_t);
dispatch_async(self.concurrent_queue, ^{
NSLog(@"dispatch_group_3===%d===%@",i,[NSThread currentThread]);
dispatch_group_leave(groutp_t);
});
}
dispatch_group_wait(groutp_t, DISPATCH_TIME_FOREVER);
NSLog(@"group end");
}
7、信号量的使用
GCD提供了信号量函数，提供我们进行线程安全操作，当信号量为0时等待操作，信号量大于0是，继续执行操作，，主要流程如下：
1、创建信号量对象，确定信号初始值
2、开始执行操作前检查是否需要等待，执行函数dispatch_semaphore_wait，如果当前的信号量为0则阻塞，等待信号量大于0时继续执行，执行函数完毕会使信号量减一。当一个任务执行完毕时我们需要调用dispatch_semaphore_signal函数，告诉系统一个任务执行完毕，调用后会使信号量加1。dispatch_semaphore_wait和dispatch_semaphore_signal函数应当成对存在，有特别需求也可以不成对存在。当初始信号量为1时，我们可以用作线程安全锁进行使用，代码如下：
- (void)dispatch_semaphore {
dispatch_semaphore_t semaphore_t = dispatch_semaphore_create(3);
for (int i = 0; i < 10; i++) {
dispatch_semaphore_wait(semaphore_t, DISPATCH_TIME_FOREVER);
dispatch_async(self.concurrent_queue, ^{
int t = rand() % 5;
sleep(t);
NSLog(@"dispatch_semaphore===%d===%@===%d",i,[NSThread currentThread],t);
dispatch_semaphore_signal(semaphore_t);
});
}
NSLog(@"end");
}
