GCD学习笔记

作者: JemmyChen | 来源:发表于2020-01-06 17:28 被阅读0次

Grand Central Dispatch（GCD）

1.Dispatch Queue

Dispath Queue 的种类	说明
Serial Dispatch Queue(串行队列)	等待现在执行中处理结束
Concurrent Dispatch Queue（并发队列）	不等待现在执行中处理结束

1.1 dispatch_queue_create

dispatch_queue_t myQueue = dispatch_queue_create("com.example.gcd.myQueue", NULL);

第一个参数指定Serial Dispatch Queue的名称，推荐使用bundleId这样的逆序全程域名
如果生成串行队列第二个参数指定为NULL，如果生成并发队列指定为DISPATCH_QUEUE_CONCURRENT

⚠️注意！通过含有create的函数生成的对象在使用结束后都需要通过dispatch_release函数释放

直接获取系统的Serial Dispatch Queue：dispatch_get_main_queue()和Concurrent Dispatch Queue：dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)

dispatch_queue_t serailQueue = dispatch_get_main_queue(); // 主队列 串行队列
    dispatch_async(serailQueue, ^{
        sleep(2);
        NSLog(@"1 -- thread == %@",[NSThread currentThread]);
    });
    dispatch_async(serailQueue, ^{
        NSLog(@"2 -- thread == %@",[NSThread currentThread]);
    });
    dispatch_async(serailQueue, ^{
        NSLog(@"3 -- thread == %@",[NSThread currentThread]);

    });
    dispatch_async(serailQueue, ^{
        NSLog(@"4 -- thread == %@",[NSThread currentThread]);

    });
 dispatch_queue_t concurrentQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); // 全局队列 并发队列
    dispatch_async(concurrentQueue, ^{
        sleep(2);
        NSLog(@"6-- thread == %@",[NSThread currentThread]);

    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"7 -- thread == %@",[NSThread currentThread]);

    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"8 -- thread == %@",[NSThread currentThread]);

    });
    dispatch_async(concurrentQueue, ^{
        NSLog(@"9 -- thread == %@",[NSThread currentThread]);

    });

打印结果

2020-01-02 15:08:24.327030+0800 Test[5227:2097148] 7 -- thread == <NSThread: 0x283b61680>{number = 3, name = (null)} //因为6睡眠了2s，所以 7 8 9 先打印 
2020-01-02 15:08:24.327090+0800 Test[5227:2097148] 8 -- thread == <NSThread: 0x283b61680>{number = 3, name = (null)}
2020-01-02 15:08:24.327119+0800 Test[5227:2097148] 9 -- thread == <NSThread: 0x283b61680>{number = 3, name = (null)}
2020-01-02 15:08:26.332363+0800 Test[5227:2097147] 6-- thread == <NSThread: 0x283b4f180>{number = 6, name = (null)} // 6睡眠2s后，1也睡眠2s结束 所以6和1 同时打印，234 依次打印
2020-01-02 15:08:26.334294+0800 Test[5227:2097127] 1 -- thread == <NSThread: 0x283b3af00>{number = 1, name = main}
2020-01-02 15:08:26.334626+0800 Test[5227:2097127] 2 -- thread == <NSThread: 0x283b3af00>{number = 1, name = main}
2020-01-02 15:08:26.334893+0800 Test[5227:2097127] 3 -- thread == <NSThread: 0x283b3af00>{number = 1, name = main}
2020-01-02 15:08:26.335291+0800 Test[5227:2097127] 4 -- thread == <NSThread: 0x283b3af00>{number = 1, name = main}

可以看到，处于并发队列中的6 7 8 9 都开启了新的线程，1 2 3 4 还是处于主线程中。

1.2 dispatch_set_target

通过dispatch_queue_create创建的queue执行优先级跟系统默认的优先级一样，使用dispatch_set_target来变更Queue的执行优先级

 dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.myQueue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t queue1 = dispatch_queue_create("com.example.gcd.myQueue1", DISPATCH_QUEUE_CONCURRENT);
// 变更优先级
    //dispatch_set_target_queue(queue, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0)); //将queue的优先级降低
      dispatch_async(queue, ^{
      NSLog(@"1 -- thread == %@",[NSThread currentThread]);
  });
      dispatch_async(queue1, ^{
      NSLog(@"2 -- thread == %@",[NSThread currentThread]);
  });
  dispatch_release(queue);
  dispatch_release(queue1);

打印结果：

2020-01-02 16:15:34.513958+0800 Test[5260:2108203] 1 -- thread == <NSThread: 0x283d4a940>{number = 4, name = (null)}
2020-01-02 16:15:34.514032+0800 Test[5260:2108203] 2-- thread == <NSThread: 0x283d4a940>{number = 4, name = (null)}
// 变更执行优先级后
2020-01-02 16:19:21.934330+0800 Test[5275:2109810] 2-- thread == <NSThread: 0x2827ee080>{number = 6, name = (null)}
2020-01-02 16:19:21.937130+0800 Test[5275:2109810] 1 -- thread == <NSThread: 0x2827ee080>{number = 6, name = (null)}

1.3 dispatch_after

指定3秒后将指定的Block追加到Main Dispatch Queue中，代码如下:

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"waited at least three seconds");
    });

⚠️需要注意的是，dispatch_after函数并不是在指定时间后执行处理，而是在指定时间追加处理到Dispatch Queue。

第一个参数是指定时间用的dispatch_time_t类型的值，该值使用dispatch_time函数或者dispatch_walltime函数作成。
第二个参数是指定队列
执行的代码块

2. Dispatch Group

当队列中的多个任务处理结束才执行某些操作时，使用Dispatch Group可以很方便的完成。

 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");
    });
    dispatch_group_async(group, queue, ^{
        sleep(2);
        NSLog(@"2");
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"finish");
    });
dispatch_release(group);
// 打印结果
2020-01-02 17:38:15.197578+0800 Test[5304:2124319] 1
2020-01-02 17:38:17.201227+0800 Test[5304:2124316] 2
2020-01-02 17:38:17.201586+0800 Test[5304:2124321] finish // 当2打印后队列中的任务完成，打印finish

⚠️需要注意的是，dispatch_group_notify只关心队列中的任务是否完成，不会关心是否是异步任务。如果需要等到队列中的异步任务完成后再执行下一步操作可配合dispatch_group_enter(group)和dispatch_group_leave(group)进行。

例如将任务2换成一个异步任务：

  dispatch_group_async(group, queue, ^{
    dispatch_async(queue, ^{
                sleep(2);
                NSLog(@"2");
            });
    });
// 打印结果
2020-01-02 17:47:08.139217+0800 Test[5311:2125947] 1
2020-01-02 17:47:08.139341+0800 Test[5311:2125945] finish
2020-01-02 17:47:10.144397+0800 Test[5311:2125947] 2
// 可以看到任务1完成后 直接打印了finish，这里并不是说没有执行任务2，只不过因为任务2是一个异步任务，调用完任务2后，任务2开启异步线程开始睡眠，队列执行完毕打印finish。2s后任务2中的异步任务执行完成打印2.

2.1 dispatch_group_enter()和dispatch_group_leave()

dispatch_group_enter 和 dispatch_group_leave 一般是成对出现的, 进入一次，就得离开一次。也就是说，当离开和进入的次数相同时，就代表任务组完成了。如果enter比leave多，那就是没完成，如果leave调用的次数多了，会崩溃的；通常dispatch_group_enter()和dispatch_group_leave()用于网络通信中。

我们在上面的例子中加入dispatch_group_enter()和dispatch_group_leave()

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_group_t group = dispatch_group_create();
    dispatch_group_enter(group);
    dispatch_group_async(group, queue, ^{
        NSLog(@"1");
        dispatch_group_leave(group);
    });
    dispatch_group_enter(group);
    dispatch_group_async(group, queue, ^{
        dispatch_async(queue, ^{
            sleep(2);
            NSLog(@"2");
            dispatch_group_leave(group);
        });
    });
    dispatch_group_notify(group, queue, ^{
        NSLog(@"finish");
    });
    dispatch_release(group);
2020-01-08 20:17:59.868014+0800 Test[6638:2555431] 1
2020-01-08 20:18:01.874152+0800 Test[6638:2555431] 2
2020-01-08 20:18:01.874416+0800 Test[6638:2555431] finish // 可以看到加入dispatch_group_enter(group)和dispatch_group_leave(group)后，等待2执行完成后才执行finish

2.2 dispatch_barrier_async

dispatch_barrier_async函数会等待追加到Concurrent Dispatch Queue上的并行执行的处理全部结束之后，再将指定的处理追加到改队列中，然后再等dispatch_barrier_async函数追加的处理执行完毕后，队列才恢复为一般动作，追加到该队列的处理又开始并执行。

⚠️注意 dispatch_barrier_async只能搭配自定义并行对列dispatch_queue_t使用。不能使用dispatch_get_global_queue,否则dispatch_barrier_async的作用和dispatch_async的作用一模一样.

dispatch_queue_t queue = dispatch_queue_create("com.example.gcd.myQueue",DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
        NSLog(@"1");
    });
 
    dispatch_barrier_async(queue, ^{
        sleep(2);
        NSLog(@"3");
    });
    dispatch_async(queue, ^{
        NSLog(@"2");
    });
//打印结果
2020-01-03 09:34:37.240138+0800 Test[5362:2163237] 1
2020-01-03 09:34:39.245367+0800 Test[5362:2163237] 3 // 打印完1后，2s后打印3跟2
2020-01-03 09:34:39.245688+0800 Test[5362:2163237] 2

2.3 dispatch_sync

既然有“async”，当然也就有“sync”，即dispatch_sync函数。它意味着“同步”(synchronous)，也就是将指定的Block“同步”追加到指定的Dispatch Queue中。在追加Block结束前，dispatch_sync函数会一直等待。

⚠️注意：异步并发会开启新线程，异步串行只会开启一条新线程（所有的异步任务都在同一个线程排队执行），同步函数都在主队列中执行（不管是串行还是并发）。主队列同步任务会导致死锁

2.4 dispatch_apply

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

 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
  dispatch_apply(10, queue, ^(size_t index) {

      NSLog(@"%zu",index);
  });
  NSLog(@"done");
// 打印结果
2020-01-08 15:19:09.761125+0800 Test[6253:2493707] 0
2020-01-08 15:19:09.761162+0800 Test[6253:2493707] 1
2020-01-08 15:19:09.761171+0800 Test[6253:2493707] 2
2020-01-08 15:19:09.761179+0800 Test[6253:2493707] 3
2020-01-08 15:19:09.761186+0800 Test[6253:2493707] 4
2020-01-08 15:19:09.761195+0800 Test[6253:2493707] 5
2020-01-08 15:19:09.761203+0800 Test[6253:2493707] 6
2020-01-08 15:19:09.761210+0800 Test[6253:2493707] 8
2020-01-08 15:19:09.761216+0800 Test[6253:2493707] 9
2020-01-08 15:19:09.761211+0800 Test[6253:2493725] 7
2020-01-08 15:19:09.761243+0800 Test[6253:2493707] done
  因为在并发队列中执行，所以各个处理的时间不定。但是done肯定是在最后的输出的。这是因为dispath_apply函数会等待全部处理执行结束。

2.5 dispatch_suspend/dispatch_resume

dispatch_suspend(queue)：挂起指定的queue。挂起后，队列中尚未执行的处理在此之后停止执行。

dispatch_resume(queue)：恢复指定的queue。恢复后，停止执行的处理继续执行。

3. Dispatch Semaphore

Dispatch Semaphore 是持有计数的信号，该计数是多线程编程中的计数类型信号。所谓信号，类似于过马路时常用的手旗。可以通过时举起手旗，不可以通过时放下手旗。而在Dispatch Semaphore中，使用计数来实现该功能。计数为0时等待，计数为1或者大于1时，减去1而不等待。

创建方法：dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

等待方法：dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

dispatch_semaphore_wait函数等待的计数值大于等于1时，对该计数减1并返回。如果是0着等待。

计数加1:dispatch_semaphore_signal(semaphore);

例如将所有数据添加到NSMutableArray中。

NSMutableArray *array = [NSMutableArray new];
    for (int i = 0; i < 100000; i++) {
        dispatch_async(queue, ^{
            [array addObject:@(i)];
        });
    }
// 因为使用并发队列更新数组，访问数组的线程有很多，很大概率会导致内存错误。
//如果使用Dispatch Semaphore
 dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

    NSMutableArray *array = [NSMutableArray new];
    for (int i = 0; i < 100000; i++) {
        dispatch_async(queue, ^{
            dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
          //加上Dispatch Semaphore后，执行到此时的semaphore为0，能访问NSMutableArray对象的线程只有1个，可以安全的进行更新
            [array addObject:@(i)];
          //更新处理完成后，semaphore加1，上面等待的线程继续执行
            dispatch_semaphore_signal(semaphore);
          
        });
    }
    dispatch_release(semaphore);

4. dispatch_once

dispatch_once函数是保证在应用程序执行中只执行一次指定处理的API。

    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
       /*
        * 初始化
        */
    });

5. dispatch_source_t

常用的定时器操作

dispatch_source_t timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_main_queue());
    // 1s后开始执行 每2s重复一次
    dispatch_source_set_timer(timer, DISPATCH_TIME_NOW, 2ull * NSEC_PER_SEC, 1ull * NSEC_PER_SEC);
    dispatch_source_set_event_handler(timer, ^{
        /**
         执行处理事件
         */
        //满足条件时取消定时器处理
        //dispatch_source_cancel(timer);
    });
    
    // 定时器取消时的处理
    dispatch_source_set_cancel_handler(timer, ^{
        // 释放定时器
        dispatch_release(timer);
    });
    
    //启动定时器
    dispatch_resume(timer);