iOS多线程之GCD

Grand Central Dispatch (GCD)是Apple开发的一个多核编程的解决方法。dispatch queue分成以下三种：

• 运行在主线程的Main_queue，通过dispatch_get_main_queue获取。dispatch_get_main_queue也是一种dispatch_queue_t。
• 并行队列global dispatch queue，通过dispatch_get_global_queue获取，由系统创建三个不同优先级的dispatch_queue。并行队列的执行顺序与其加入队列的顺序相同。
• 串行队列serial queues一般用于按顺序同步访问，可创建任意数量的串行队列，各个串行队列之间是并发的。
  当想要任务按照某一个特定的顺序执行时，串行队列是很有用的。串行队列在同一个时间只执行一个任务。我们可以使用串行队列代替锁去保护共享的数据。和锁不同，一个串行队列可以保证任务在一个可预知的顺序下执行。
  serial queues通过dispatch_queue_create创建，可以使用函数dispatch_retain和dispatch_release去增加或者减少引用计数。

严格来说，GCD并非多线程，而是一个队列。

GCD的用法：

1、并行队列 + 同步执行

- (void)gcdDemo1 {
    /* 
        DISPATCH_QUEUE_CONCURRENT 并发
        DISPATCH_QUEUE_SERIAL 串行
     */
    
    NSLog(@"嘿嘿-----------");
    dispatch_queue_t q = dispatch_queue_create("ptl", DISPATCH_QUEUE_CONCURRENT);
    dispatch_sync(q, ^{
        for (NSInteger i = 0; i < 10; i ++) {
            // 任务在并发子线程执行 所以下面的"哈哈" 可能在for之前 也可能之后
            dispatch_async(q, ^{
                NSLog(@"😆(%zd)--%@", i, [NSThread currentThread]);
            });
        }
    });
    
    NSLog(@"哈哈-----------");
}

2、 并行队列 + 异步执行

- (void)gcdDemo2 {
    /*
     先执行"嘿嘿", 下面的代码都是随机执行 "哈哈"可能在for前,后或者中间打印
     
     */
    NSLog(@"嘿嘿-----------");
    
    dispatch_queue_t q = dispatch_queue_create("ptl", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(q, ^{
        for (NSInteger i = 0; i < 10; i ++) {
            dispatch_async(q, ^{
                NSLog(@"😆(%zd)--%@", i, [NSThread currentThread]);
            });
        }
    });
    NSLog(@"哈哈-----------");
}

3、串行队列 + 同步执行

- (void)gcdDemo3 {
    
    /*
     DISPATCH_QUEUE_SERIAL : 串行
     按照顺序执行
     */
    NSLog(@"嘿嘿-----------");
    dispatch_queue_t q = dispatch_queue_create("ptl", DISPATCH_QUEUE_SERIAL);
    dispatch_sync(q, ^{
        for (NSInteger i = 0; i < 10; i ++) {
            dispatch_async(q, ^{
                NSLog(@"😆(%zd)--%@", i, [NSThread currentThread]);
            });
        }
    });
    NSLog(@"哈哈-----------");
}

4、串行队列 + 异步执行

- (void)gcdDemo4 {
    
    /*
        先执行"嘿嘿", 后面的会随机执行, "哈哈"可能会插入到for中打印
        for是在串行异步执行 所以子线程会执行完当前任务后才会执行下次任务
     */
    
    NSLog(@"嘿嘿-----------");
    dispatch_queue_t q = dispatch_queue_create("ptl", DISPATCH_QUEUE_SERIAL);
    dispatch_async(q, ^{
        for (NSInteger i = 0; i < 2; i ++) {
            dispatch_async(q, ^{
                NSLog(@"😆(%zd)--%@", i, [NSThread currentThread]);
            });
        }
    });
    NSLog(@"哈哈-----------");
    
}

5、主队列 + 同步执行

- (void)gcdDemo5 {
    
    /*
        "嘿嘿"等待for的任务执行完往下执行 而for又等待"嘿嘿"执行完往下执行 所以互相等待 程序卡死 崩溃
     */
    NSLog(@"嘿嘿-----------");
    dispatch_sync(dispatch_get_main_queue(), ^{
        for (NSInteger i = 0; i < 10; i ++) {
            NSLog(@"😆(%zd)--%@", i, [NSThread currentThread]);
        }
    });
    
    NSLog(@"哈哈-----------");
}

6、主队列 + 异步执行

- (void)gcdDemo6 {
    /*
        先执行"嘿嘿"->"哈哈"->for里面 for里面的任务会在主队列执行 添加到主队列后不会立马就执行的 会等待一会 所以"哈哈"在for之前就执行了 因为它本身就在主线程中无需等待
     */
    NSLog(@"嘿嘿-----------");
    dispatch_async(dispatch_get_main_queue(), ^{
        for (NSInteger i = 0; i < 10; i ++) {
            NSLog(@"😆(%zd)--%@", i, [NSThread currentThread]);
        }
    });
    
    NSLog(@"哈哈-----------");
}

7、栅栏方法

• dispatch_barrier_async
  有时需要异步执行两组操作，而且第一组操作执行完之后，才能开始执行第二组操作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的操作组给分割起来，操作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个操作组间形成栅栏。

- (void)gcdDemo7 {

    /*
        "1"和"2"处于子线程会随机打印顺序 然后打印栅栏"3" 最后打印"4"
     */
    
   dispatch_queue_t q = dispatch_queue_create("ptl", DISPATCH_QUEUE_CONCURRENT);
    dispatch_async(q, ^{
        NSLog(@"----1-----%@", [NSThread currentThread]);
    });
    
    dispatch_async(q, ^{
        NSLog(@"----2-----%@", [NSThread currentThread]);
    });
    
    dispatch_barrier_async(q, ^{
        for (NSInteger i = 0; i < 10; i ++) {
//            // 加入到异步后 下面的"4"可能在for之前打印, 可能在中间打印, 也可能在for后面打印
//            dispatch_async(q, ^{
//                NSLog(@"----3 barrier-----%@", [NSThread currentThread]);
//            });
            
            NSLog(@"----3 barrier-----%@", [NSThread currentThread]);
        }
    });
    
    dispatch_async(q, ^{
        NSLog(@"----4-----%@", [NSThread currentThread]);
    }); 
}

8、快速迭代方法 dispatch_apply

dispatch_apply函数是dispatch_sync函数和Dispatch_Group的关联API,该函数按指定的次数将指定的Block追加到指定的Dispatch_Queue中,并等到全部的处理执行结束。

- (void)gcdDemo8 {

    dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    /**
     同时遍历6次 不按顺序输出
     @param iterations 遍历的次数
     @param queue 在哪个队列
     @param size_t index下标号
     */
    dispatch_apply(6, q, ^(size_t index) {
        NSLog(@"%zd----%@", index, [NSThread currentThread]);
    });
}

9、队列组 dispatch_group

多个任务处理完毕之后想执行结束处理，这种需求会经常出现。如果只是使用一个Serial Dispatch Queue（串行队列）时，只要将想执行的处理全部追加到该串行队列中并在最后追加结束处理即可，但是在使用Concurrent Queue 时，可能会同时使用多个Dispatch Queue时，代码就会变得很复杂。在这种情况下，就可以使用Dispatch Group。

- (void)gcdDemo9 {
    /*
        "3"会等待前面的"1""2"打印完才会打印, "1""2"异步操作会交替打印
     */
    // 创建一个组队列
    dispatch_group_t group = dispatch_group_create();
    // 创建一个异步组队列
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 执行1个耗时的异步操作
        for (NSInteger i = 0; i < 10; i ++) {
            NSLog(@"1----%zd---%@",i, [NSThread currentThread]);
        }
    });
    
    dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        // 执行1个耗时的异步操作
        for (NSInteger i = 0; i < 10; i ++) {
            NSLog(@"2----%zd---%@",i, [NSThread currentThread]);
        }
    });
    
    dispatch_group_notify(group, dispatch_get_main_queue(), ^{
        // 等前面的异步操作都执行完毕后，回到主线程...
        for (NSInteger i = 0; i < 10; i ++) {
            NSLog(@"3----%zd---%@",i, [NSThread currentThread]);
        }
    });
}

10、信号量dispatch_semaphore

项目中的业务接口请求的时候需要Token验证。我们最简化这个需求就是：两个请求，请求1成功返回所需参数之后，才能开始请求2。

// 信号量
- (void)dispatch_semaphore {
    
    /*
     //创建信号量
     dispatch_semaphore_create
     //发送信号量
     dispatch_semaphore_signal
     //等待信号量
     dispatch_semaphore_wait
     */
    
    dispatch_async(dispatch_queue_create("ptl", DISPATCH_QUEUE_CONCURRENT), ^{
        
        dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);

        // 请求接口1
        [self getToken:semaphore];
        //此时的信号量为0，只有token请求成功发送信号量之后，才会往下执行[self request]方法，否则会一直等下去;
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        // 请求接口2
        [self requestData1:semaphore];
        dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

        // 请求接口3
        [self requestData2];
    });
}

- (void)getToken:(dispatch_semaphore_t)semaphore
{
    // 模仿网络请求
    for (NSInteger i = 0; i < 20; i ++) {
        NSLog(@"请求1-------%zd", i);
        // 模仿请求成功
        //成功拿到token，发送信号量
        dispatch_semaphore_signal(semaphore);
    }
    NSLog(@"------------请求1成功-----------------");
}

- (void)requestData1:(dispatch_semaphore_t)semaphore {
    for (NSInteger i = 0; i < 20; i ++) {
        NSLog(@"请求2-------%zd", i);
        dispatch_semaphore_signal(semaphore);
    }
    NSLog(@"------------请求2成功-----------------");
}

- (void)requestData2 {
    for (NSInteger i = 0; i < 20; i ++) {
        NSLog(@"请求3-------%zd", i);
    }
    NSLog(@"------------请求3成功-----------------");
}

Github: https://github.com/soliloquy-local/GCD.git
以上就是对GCD各个情况的简单介绍，主要以代码为主...😁