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

swift版本

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + 2, execute: DispatchWorkItem(block: {

}))

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");
}

8、GCD的source事件

GCD可以监听事件源对象，创建事件源对象方法如下：

dispatch_source_t
dispatch_source_create(dispatch_source_type_t type,
    uintptr_t handle,
    uintptr_t mask,
    dispatch_queue_t _Nullable queue);

事件源类型有很多种，如下所示：

    // 自定义事件,触发事件后的数据会被叠加运算
    #define DISPATCH_SOURCE_TYPE_DATA_ADD
    // 自定义事件,触发时间后的数据会被按位或运算
    #define DISPATCH_SOURCE_TYPE_DATA_OR
    // 自定义事件,触发时间后的数据会被替换
    #define DISPATCH_SOURCE_TYPE_DATA_REPLACE
    // 内核端口发送数据事件
    #define DISPATCH_SOURCE_TYPE_MACH_SEND
    // 内核端口接收数据事件
    #define DISPATCH_SOURCE_TYPE_MACH_RECV
    // 内存压力事件
    #define DISPATCH_SOURCE_TYPE_MEMORYPRESSURE
    // 进程相关事件
    #define DISPATCH_SOURCE_TYPE_PROC
    // 读文件相关事件
    #define DISPATCH_SOURCE_TYPE_READ
    // 写文件相关事件
    #define DISPATCH_SOURCE_TYPE_WRITE
    // 信号相关事件
    #define DISPATCH_SOURCE_TYPE_SIGNAL
    // 定时器事件
    #define DISPATCH_SOURCE_TYPE_TIMER
    // 文件属性修改事件
    #define DISPATCH_SOURCE_TYPE_VNODE

创建事件源之后，我们需要设置回调函数，如下：

void
dispatch_source_set_event_handler(dispatch_source_t source,
    dispatch_block_t _Nullable handler);

注意创建的dispatch_source_t对象需要我们进行强引用，持有对象。
最后我们需要激活对象，方法如下，传入dispatch_source_t作为参数。

void
dispatch_activate(dispatch_object_t object);

定时器是我们常使用的一种任务逻辑，当我们需要较高精度的定时器时我们可以使用GCD source的定时器执行任务，示例代码如下：

- (void)dispatch_source_timer {
    dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, self.serial_queue);
    dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 1 * NSEC_PER_SEC, 0 * NSEC_PER_SEC);
    dispatch_source_set_event_handler(timer, ^{
        NSLog(@"dispatch_source_timer %@",[NSThread currentThread]);
    });
    dispatch_activate(timer);
    self.timer = timer;
}

demo地址