关于dispatch的其他常用东西

一、各种队列。
如下代码，看注释。

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
//    串行的特点是等待结束，第二个任务结束看到前一个任务结束，它才开始，
//    并行的特点是等待发生，第二个任务看到前一个任务开始，不管前一个任务是否结束它就开始
    
//    普通串行 --- 第一个参数是队列名称，第二个表示串行还是并行
    dispatch_queue_t serialQueue = dispatch_queue_create("小明串行", DISPATCH_QUEUE_SERIAL);
//    普通并行
    dispatch_queue_t concurrentQueue = dispatch_queue_create("小红并行", DISPATCH_QUEUE_CONCURRENT);

//    主队列
    dispatch_queue_t mainQueue = dispatch_get_main_queue();
    
//    全局队列，和普通并行没啥区别 -- 第一个参数表示优先级，根据字面意思就能理解。后面的数字是个flags（一般情况下没个卵用，随便写个数字就行了）
    dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    
//    同步和异步表示这个任务的执行方式，需不需要新建子线程去执行这个任务。
//    前面是队列，block里是具体的任务
    dispatch_async(concurrentQueue, ^{
        
        NSLog(@"666_SunDePrint_999:%@", @"打印任务");
    });
}

二、dispatch_after 延迟执行

定义： dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC));
DISPATCH_TIME_NOW：表示当前时间，后面的数字是多少秒后。

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    //主队列延时
    dispatch_time_t when_main = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(5.0 * NSEC_PER_SEC));
    dispatch_after(when_main, dispatch_get_main_queue(), ^{
        
        NSLog(@"主队列延时%@",[NSThread currentThread]);
        NSLog(@"666_SunDePrint_999:%@", @"打印1");
    });
    
    //全局队列延时
    dispatch_time_t when_global = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC));
    dispatch_after(when_global, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        NSLog(@"全局队列延时%@",[NSThread currentThread]);
        NSLog(@"666_SunDePrint_999:%@", @"打印2");
    });
    
    //普通并行队列延时
    dispatch_time_t tiemConcurrent = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(3.0 * NSEC_PER_SEC));
    dispatch_queue_t serialQueue = dispatch_queue_create("AAAA", DISPATCH_QUEUE_CONCURRENT);
    dispatch_after(tiemConcurrent, serialQueue, ^{
        
        NSLog(@"普通并行队列延时_%@",[NSThread currentThread]);
        NSLog(@"666_SunDePrint_999:%@", @"打印3");
    });
    
    //普通串行队列延时
    dispatch_time_t timeSei = dispatch_time(DISPATCH_TIME_NOW, (int64_t)(6.0 * NSEC_PER_SEC));
    dispatch_queue_t comQueue = dispatch_queue_create("BBBB", DISPATCH_QUEUE_CONCURRENT);
    dispatch_after(timeSei, comQueue, ^{
        NSLog(@"普通串行队列延时_%@",[NSThread currentThread]);
        NSLog(@"666_SunDePrint_999:%@", @"打印4");
    });
}

延迟打印结果.png

根据结果分析，其实全局队列和普通并行本质一样，所以结果也一样。
除了主队列，其他队列中的任务都在子线程中执行的，说明dispatch_after执行的时候创建了新线程。和dispatch_async异步执行异曲同工。主队列的时候由于防止死锁的情况，也作了妥协，就在主线程中执行任务了。（具体可参照上一篇文章）

三、dispatch_once_t

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"%@",[NSThread currentThread]);
    });
}

它的作用就是保证任务只执行一次，保存在内存中，常用于创建单例。

四、dispatch_group_t任务组和dispatch_group_notify任务通知函数

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    dispatch_group_t taskGroup = dispatch_group_create();

    dispatch_group_async(taskGroup, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"666_SunDePrint_999:%@", @"任务1");
        NSLog(@"任务1%@", [NSThread currentThread]);
    });
    
    dispatch_group_async(taskGroup, dispatch_get_global_queue(0, 0), ^{
        NSLog(@"666_SunDePrint_999:%@", @"任务2");
        NSLog(@"任务2%@", [NSThread currentThread]);
    });
    
    dispatch_group_notify(taskGroup, dispatch_get_main_queue(), ^{
        NSLog(@"666_SunDePrint_999:%@", @"所有任务结束");
        NSLog(@"所有任务结束%@", [NSThread currentThread]);
    });
}

group看着就是任务组的意思。把任务放到一个组里。等左右任务做完了dispatch_group_notify执行，做想做的事。
常用于多个网络请求，但是页面需要在所有数据请求完才能显示，用这个就很方便了。

五、dispatch_barrier_async 栅栏函数

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    
    dispatch_queue_t comQueue = dispatch_queue_create("AAA", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(comQueue, ^{
        NSLog(@"666_SunDePrint_999:%@", @"任务1");
    });
    
    dispatch_async(comQueue, ^{
        NSLog(@"666_SunDePrint_999:%@", @"任务2");
    });

    dispatch_barrier_async(comQueue, ^{
        NSLog(@"666_SunDePrint_999:%@", @"栅栏任务");
    });
    
    dispatch_async(comQueue, ^{
        NSLog(@"666_SunDePrint_999:%@", @"任务3");
    });
    
    dispatch_async(comQueue, ^{
        NSLog(@"666_SunDePrint_999:%@", @"任务4");
    });
}

栅栏函数打印结果.png

通过结果明显看到，这个函数把几个异步执行的任务分开了。常用于好几个异步请求，但是有几个必须先执行，但是这几个没有顺序，前一部分执行完，后面几个再执行，后面的几个相互间没顺序。
PS：如果只有2个网络请求，还要求有先后顺序，low逼但是简单省事的做法就是把后一个网络请求写到第一个的请求里面。还有种做法就是把这2个任务添加都一个串行队列里，再异步执行，既保证了在子线程中执行任务，又保证了2个任务的顺序，最后用个全局变量做个标记，看任务否成功失败。也能做到这个效果。

六、dispatch_apply重复执行函数

- (void)viewDidLoad {
    [super viewDidLoad];
    // Do any additional setup after loading the view, typically from a nib.
    
    dispatch_queue_t comQueue = dispatch_queue_create("AAA", DISPATCH_QUEUE_CONCURRENT);
    dispatch_queue_t seiQueue = dispatch_queue_create("BBB", DISPATCH_QUEUE_SERIAL);

    dispatch_apply(5, comQueue, ^(size_t index) {
        NSLog(@"666_SunDePrint_999:%@ 第%@次", @"任务1", @(index));
        NSLog(@"%@", [NSThread currentThread]);
    });
}

重复执行结果.png

根据结果，显示这个函数和队列的关系比较大，会根据队列类型选择是否创建新线程。如果是串行队列，说明程序员想要任务按顺序执行，不需要新线程，都在主线程执行，相当于写个for循环。如果是并行队列，说明程序员想同时执行任务，需要新建子线程。如果是主队列，还会造成死锁。为啥？。

啊啊啊啊啊啊.gif