iOS 多线程：GCD总结

2019-01-18 本文已影响13人丶墨墨丶

主要总结一下平时iOS开发中用到的GCD内容，和没有用到的相关API，以备日后开发中使用。昨天面试时候被问到多线程的一些内容，比如线程间的依赖，回答的不是太好！在一些业务不是太复杂或者用户量较少的项目中，很少有地方需要太复杂的GCD操作。

队列和任务

队列（Dispatch Queue）

这里的队列跟数据结构里提到的队列概念一样，一种特殊的线性表，（FIFO）先进先出。在GCD中主要用来存放任务，从队头读取任务，从队尾加入新的任务。

串行队列
每次只能执行一个任务。
并行队列
可以同时执行多个任务，同时开启多个线程执行任务。只有被添加到async中才会这样执行

// dispatch_queue_create 创建队列
- (void)GCD_queue
{
    // 串行队列
    dispatch_queue_t serialQueue = dispatch_queue_create("serial_queue_Identifier", DISPATCH_QUEUE_SERIAL);
    _serialQueue = serialQueue;
    // 并行队列
    dispatch_queue_t concurrentQueue = dispatch_queue_create("concurrent_queue_identifier", DISPATCH_QUEUE_CONCURRENT);
    _concurrentQueue = concurrentQueue;
    
    NSLog(@"%s -------------- dispatch_queue_create", __func__);
}

任务:sync(同步执行)、async(异步执行)

sync（同步执行）
不具备开线程的能力，只能在当前线程执行

// sync + 串行队列 = 不会开线程、任务顺序执行
- (void)CGD_sync_serialQueue
{
    for (int i = 0; i < 5; i++) {
        dispatch_sync(_serialQueue, ^{
            NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
        });
    }
}

// sync + 并行队列 = 不会开线程、任务顺序执行
- (void)GCD_sync_concurrentQueue
{
    for (int i = 0; i < 5; i++) {
        dispatch_sync(_concurrentQueue, ^{
            NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
        });
    }
}

async（异步执行）
具备开线程的能力，但是不一定会开辟新的线程，这和任务添加的队列有关，任务的执行不需要等待

// async + 串行队列 = 只开一个线程、在此线程中顺序执行
- (void)GCD_async_serialQueue
{
    for (int i = 0; i < 5; i++) {
        dispatch_async(_serialQueue, ^{
            NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
        });
    }
}

// async + 并行队列 = 开多个线程、任务并行执行
- (void)GCD_async_concurrentQueue
{
    for (int i = 0; i < 5; i++) {
        dispatch_async(_concurrentQueue, ^{
            NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
        });
    }
}

另外两种特殊的组合
sync + dispatch_get_main_queue() : 在主线程会造成死锁，相互等待造成死锁，在子线程不会造成死锁

- (void)GCD_sync_mainQueue_in_subThread
{
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"%s ---Thread：%@---", __func__, [NSThread currentThread]);
        for (int i = 0; i < 5; i++) {
            dispatch_sync(dispatch_get_main_queue(), ^{
                NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
            });
        }
    });
    
}

async + dispatch_get_main_queue() : 任务在主线程中顺序执行

- (void)GCD_async_mainQueue
{
    for (int i = 0; i < 5; i++) {
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"%s ---Thread：%@--- %d", __func__, [NSThread currentThread], i);
        });
    }
}

任务依赖：dispatch_barrier_async

GCD 栅栏方法：dispatch_barrier_async：
在有些情况下，我们需要任务A必须在任务B之前执行，这时候在GCD里我们就用到dispatch_barrier_async函数，他保证dispatch_barrier_async之前的任务先执行，然后再执行dispatch_barrier_async 的任务，最后执行dispatch_barrier_async之后的任务。

//- GCD 栅栏方法：dispatch_barrier_async
- (void)GCD_barrier_async
{
    // A任务
    for (int i = 0; i < 3; i++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"Thread：%@--- A任务 --- %d", [NSThread currentThread], i);
        });
    }
    // Barrier任务
    dispatch_barrier_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"Thread：%@--- Barrier任务", [NSThread currentThread]);
    });
    // B任务
    for (int i = 0; i < 3; i++) {
        dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"Thread：%@--- B任务 --- %d", [NSThread currentThread], i);
        });
    }
}

切记是在同一任务队列中，否则达不到我们的要求

dispatch_group + dispatch_group_notify 组合

在有些情况下，我们需要执行完任务A、任务B ·····，然后才得到通知，再去做某个任务：
首先用 dispatch_group_async 先把任务放到队列中，然后将队列放入队列组中，异步执行。
然后调用 dispatch_group_notify 方法回到指定线程，完成剩下的操作。

- (void)GCD_async_gounp_notify
{
    dispatch_group_t group = dispatch_group_create();
    
    for (int i = 0; i < 3; i++) {
        dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
            NSLog(@"Thread：%@--- A任务 --- %d", [NSThread currentThread], i);
        });
    }
    
    for (int i = 0; i < 3; i++) {
        dispatch_group_async(group, _concurrentQueue, ^{
            NSLog(@"Thread：%@--- B任务 --- %d", [NSThread currentThread], i);
        });
    }
    
    // 任务A 任务B都完成之后，执行notify的任务
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
       NSLog(@"Thread：%@--- 任务A 任务B 执行之后的操作", [NSThread currentThread]);
    });
}

可以是不同的任务队列，都会加入到dispatch_group_t组中

其他一下API

dispatch_once

平常写单例会用到

// dispatch_once_t 保证代码块中只执行一次
- (void)GCD_once
{
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"%s -------------- dispatch_once", __func__);
    });
}

dispatch_after

延迟执行

// dispatch_after 保证代码延迟执行，设定一个时间
- (void)GCD_after
{
    dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"%s -------------- dispatch_after", __func__);
    });
}

😊附上demo，如果帮到你了请给个🌟
GitHub

963.png