GCD的高级用法

一次性执行(dispatch_once_t)

实际开发中有时我们需要某个方法只执行一次，而且要保证线程是安全的，那么dispatch_once_t无疑是很好的选择。

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    [self onceTest];
}

- (void)onceTest {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        NSLog(@"%@", [NSThread currentThread]);
    });
}

执行在主线程上

<NSThread: 0x60800006b0c0>{number = 1, name = main}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        [self onceTest];
    });
}

执行在当前线程上

<NSThread: 0x608000263080>{number = 3, name = (null)}

- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
    for(int i = 0; i< 10; i++) {
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
            [self onceTest];
        });
    }
}

线程是安全的，同时开启多个任务执行once仍然只执行一次

<NSThread: 0x608000266040>{number = 3, name = (null)}

实际开发中once最常用在创建单例的对象上


#import <Foundation/Foundation.h>

@interface JYPerson : NSObject <NSCopying>

+ (instancetype)sharedPerson;

@end


#import "JYPerson.h"

@implementation JYPerson

// 定义一个静态变量，保证内存中只有一个副本，而且是保存在静态区直到程序退出才销毁
static id instance;

// 提供一个全局的访问方法（补充：有一个约定，所有的单例都是以 shared + 类名 格式定义）
+ (instancetype)sharedPerson {
    // 用dispatch_once的目的：保证对象只会被初始化（init）一次，切线程是安全的
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [[self alloc] init];
    });
    
    return instance;
}

// 重写allocWihtZone方法保证，对象只会被实例化一次，只分配一次内存空间
+ (instancetype)allocWithZone:(struct _NSZone *)zone {
    // 用dispatch_once的目的：在多线程运行在保证allocWithZone只调用一次，即内存只分配一次
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        instance = [super allocWithZone:zone];
    });
    return instance;
}

- (id)copyWithZone:(NSZone *)zone {
    //    return [[self.class allocWithZone:zone] init];
    // 对象方法，说明拷贝的源已经存在 => instance 就一定已经被实例化过，所以这里直接返回实例instance
    return instance;
}

@end

顺便介绍下Swift中单利写法(dispatch_once_t在swift中被废弃了)

import UIKit

class JYPerson: NSObject {
    static let shareInstance: JYPerson = {
        return JYPerson()
    }()
}

延时操作

// OC
/**
参数1: dispatch_time_t when
多少纳秒之后执行

参数2: dispatch_queue_t queue
执行任务的队列

 参数3: dispatch_block_t block
要执行的任务
*/
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<delayInSeconds> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        // 要执行的任务
    });

// Swift
func test2() -> () {
        // 原先的dispatch_time_t现在由DispatchTime对象表示。可以用静态方法now获得当前时间，然后再通过加上一个。DispatchTimeInterval枚举来获得一个需要延迟的时间
        print("操作一")
        
        // let delay = DispatchTime.now() + DispatchTimeInterval.seconds(3)
        // 这里也可以直接加上一个秒数
        let delay = DispatchTime.now() + 3
        DispatchQueue.main.asyncAfter(deadline: delay) {
            print("操作二：延迟了3s执行")
        }
    }

调度组(Dispatch_groups)

Dispatch Group 会在整个组的任务都完成时发出通知，这些任务可以是同步的，也可以是异步的，即便在不同的队列也行。对多个异步任务的完成进行监控的问题，这无疑是一个非常好的选择。
因为被监控的任务可能在不同的队列，因此用一个 dispatch_group_t 的实例来记下这些不同的任务。
当组中所有的事件都完成时，GCD 的 API 提供了两种通知方式。

用法一

利用 dispatch_group_wait ，它会阻塞当前线程，直到组里面所有的任务都完成或者等到某个超时发生。
因为你在使用的是同步的 dispatch_group_wait ，它会阻塞当前线程，所以你要用 dispatch_async 将整个方法放入后台队列以避免阻塞主线程。

// OC
- (void)groupTest {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 创建一个dispatch_group
        dispatch_group_t group = dispatch_group_create();
        
        // 手动通知进入dispatch_group_t(你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题)
        dispatch_group_enter(group);
        
        NSLog(@"任务1");
        [NSThread sleepForTimeInterval:3.0];
        NSLog(@"任务1");
        NSLog(@"任务1");
        
        // 手动通知结束dispatch_group_t
        dispatch_group_leave(group);
        
        // 一直等待直到dispatch_group_t中所有任务执行完毕
        dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
        dispatch_async(dispatch_get_main_queue(), ^{
            NSLog(@"拉回主线程刷新UI");
        });
    });
}

// Swift
 func groupTest() -> () {
        DispatchQueue.global().async {
            // 创建一个dispatch_group
            let group = DispatchGroup();
            
            // 手动通知进入dispatch_group_t(你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题)
            group.enter()
            
            print("任务1")
            print("任务2")
            print("任务3")
            
            group.leave()
            
            // 一直等待直到dispatch_group_t中所有任务执行完毕
            group.wait()
            
            DispatchQueue.main.async(execute: {
                print("拉回主线程刷新UI")
            })
        }
    }

控制台输出结果

[1670:108365] 任务1
[1670:108365] 任务2
[1670:108365] 任务3
[1670:108304] 拉回主线程刷新UI

基本实现过程：
创建一个group ，执行groupenter 和 leave 中间的代码，然后再利用dispatch_group_wait 让线程阻塞在这里一直等待，最后再去执行刷新UI或者处理group结果的部分

用法二

然而，用阻塞线程这种方法显得不是那么友好，我们来看看第二种，不阻塞线程的方法：dispatch_group_notify

// OC
- (void)groupTest {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 创建一个dispatch_group
        dispatch_group_t group = dispatch_group_create();
        
        // 手动通知进入dispatch_group_t(你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题)
        dispatch_group_enter(group);
        
        NSLog(@"任务1");
        [NSThread sleepForTimeInterval:3.0];
        NSLog(@"任务2");
        NSLog(@"任务3");
        
        // 手动通知结束dispatch_group_t
        dispatch_group_leave(group);
        
        dispatch_group_notify(group, dispatch_get_main_queue(), ^{
            NSLog(@"拉回主线程刷新UI");
        });
    });
}

// Swift
func groupTest() -> () {
        DispatchQueue.global().async {
            // 创建一个dispatch_group
            let group = DispatchGroup();
            
            // 手动通知进入dispatch_group_t(你必须保证 dispatch_group_enter 和 dispatch_group_leave 成对出现，否则你可能会遇到诡异的崩溃问题)
            group.enter()
            
            print("任务1")
            print("任务2")
            print("任务3")
            
            group.leave()
            
            let workItem = DispatchWorkItem(block: {
                print("拉回主线程刷新UI")
            })
            group.notify(queue: DispatchQueue.main, work: workItem)
        }
    }

控制台输出结果

[1670:108365] 任务1
[1670:108365] 任务2
[1670:108365] 任务3
[1670:108304] 拉回主线程刷新UI

用法三(平时开发最常用)

// OC
- (void)groupTest {
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        // 创建一个dispatch_group
        dispatch_group_t group = dispatch_group_create();
        
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            NSLog(@"任务1");
        });
        
        dispatch_group_async(group, dispatch_get_global_queue(0, 0), ^{
            NSLog(@"任务2");
        });

        dispatch_group_notify(group, dispatch_get_global_queue(0, 0), ^{
            NSLog(@"任务3");
        });
    });
}

// Swift
func groupTest() -> () {
        DispatchQueue.global().async {
            // 创建一个dispatch_group
            let group = DispatchGroup()
            
            let queueOne = DispatchQueue(label: "queueOne")
            queueOne.async(group: group) {
                print("任务1")
            }
            
            let queueTwo = DispatchQueue(label: "queueTwo")
            queueTwo.async(group: group) {
                print("任务2")
            }
            
            group.notify(queue: DispatchQueue.main) {
                print("任务3")
            }
        }
    }

控制台输出结果

任务1
任务2
任务3
或者
任务2
任务1
任务3

任务1和任务2是异步的所以先后顺序不可控，任务3只有在group中所有任务执行完毕调用

dispatch_barrier

在并行队列中，为了保持某些任务的顺序，需要等待一些任务完成后才能继续进行，使用 barrier 来等待之前任务完成，避免数据竞争等问题。假设我们有一个并发的队列用来读写一个数据对象。如果这个队列里的操作是读的，那么可以多个同时进行。如果有写的操作，则必须保证在执行写入操作时，不会有读取操作在执行，必须等待写入完成后才能读取，否则就可能会出现读到的数据不对。OC用dipatch_barrier实现。Swift中用DispatchWorkItemFlags实现。

// OC
- (void)barrierTest {
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    
    dispatch_async(queue, ^{
        NSLog(@"任务1");
    });
    dispatch_async(queue, ^{
        NSLog(@"任务2");
        [NSThread sleepForTimeInterval:2.0];
    });
    
    dispatch_barrier_async(queue, ^{
        NSLog(@"barrier测试");
    });
    
    dispatch_async(queue, ^{
        NSLog(@"任务3");
    });
}

// Swift
func barrierTest() -> () {
        let queue = DispatchQueue(label: "queue", attributes: .concurrent)
        
        queue.async { 
            print("任务1")
        }
        queue.async {
            print("任务2")
            Thread.sleep(forTimeInterval: 2.0)
        }
        
        let barrierWorkItm = DispatchWorkItem(flags: .barrier) {
            print("barrier测试")
        }
        queue.async(execute: barrierWorkItm)
        
        queue.async {
            print("任务3")
        }
    }

控制台输出结果

任务1
任务2
barrier测试
任务3
或
任务2
任务1
barrier测试
任务3

任务1和任务2是异步的所以先后顺序不可控，barrier会等待当前队列中先于自己添加的任务完成再执行，并阻塞当前线程，等待barrier函数执行完毕当前线程才恢复之前的动作继续执行，任务3只barrier函数执行完毕后才能调用。

注意：使用 dispatch_barrier_async ，该函数只能搭配自定义并行队列 dispatch_queue_t 使用。不能使用： dispatch_get_global_queue ，否则 dispatch_barrier_async 的作用会和 dispatch_async 的作用一模一样。

dispatch_apply

作用：按指定的次数将指定的Block追加到指定的Dispatch Queue中,并等到全部的处理执行结束(类似for循环)

并行队列

- (void)apply {
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);
    dispatch_apply(5, queue, ^(size_t index) {
        NSLog(@"当前线程：%@, index: %zu",[NSThread currentThread], (index + 1));
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"done");
    });
}

控制台输出结果：并行队列上是并发执行的，但并非所有任务都开辟新线程，也有在主线程中完成的。dispatch_apply会阻塞线程，直到dispatch_apply函数执行完毕才继续往下走，所有done最后打印

当前线程：<NSThread: 0x600000075ac0>{number = 4, name = (null)}, index: 3
当前线程：<NSThread: 0x60800006a9c0>{number = 1, name = main}, index: 1
当前线程：<NSThread: 0x608000078440>{number = 5, name = (null)}, index: 4
当前线程：<NSThread: 0x608000078640>{number = 3, name = (null)}, index: 2
当前线程：<NSThread: 0x600000075ac0>{number = 4, name = (null)}, index: 5
done

串行队列

- (void)applyTest {
    dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
    dispatch_apply(5, queue, ^(size_t index) {
        NSLog(@"当前线程：%@, index: %zu",[NSThread currentThread], (index + 1));
    });
    
    dispatch_async(dispatch_get_global_queue(0, 0), ^{
        NSLog(@"done");
    });
}

控制台输出结果：

当前线程：<NSThread: 0x600000075ac0>{number = 4, name = (null)}, index: 1
当前线程：<NSThread: 0x60800006a9c0>{number = 1, name = main}, index: 2
当前线程：<NSThread: 0x608000078440>{number = 5, name = (null)}, index: 3
当前线程：<NSThread: 0x608000078640>{number = 3, name = (null)}, index: 4
当前线程：<NSThread: 0x600000075ac0>{number = 4, name = (null)}, index: 5
done

最后编辑于：2017.12.06 08:05:02

人面猴
序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
沈念sama阅读 161,192评论 4赞 369
死咒
序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
沈念sama阅读 68,186评论 1赞 303
救了他两次的神仙让他今天三更去死
文/潘晓璐我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
开封第一讲书人阅读 110,844评论 0赞 252
道士缉凶录：失踪的卖姜人
文/不坏的土叔我叫张陵，是天一观的道长。经常有香客问我，道长，这世上最难降的妖魔是什么？我笑而不...
开封第一讲书人阅读 44,471评论 0赞 217
港岛之恋（遗憾婚礼）
正文为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
茶点故事阅读 52,876评论 3赞 294
恶毒庶女顶嫁案：这布局不是一般人想出来的
文/花漫我一把揭开白布。她就那样静静地躺着，像睡着了一般。火红的嫁衣衬着肌肤如雪。梳的纹丝不乱的头发上，一...
开封第一讲书人阅读 40,891评论 1赞 224
城市分裂传说
那天，我揣着相机与录音，去河边找鬼。笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。我是一名探鬼主播，决...
沈念sama阅读 32,068评论 2赞 317
双鸳鸯连环套：你想象不到人心有多黑
文/苍兰香墨我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
开封第一讲书人阅读 30,791评论 0赞 205
万荣杀人案实录
序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
沈念sama阅读 34,539评论 1赞 249
护林员之死
正文独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋以下内容为张勋视角年9月15日...
茶点故事阅读 30,772评论 2赞 253
白月光启示录
正文我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
茶点故事阅读 32,250评论 1赞 265
活死人
序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
沈念sama阅读 28,577评论 3赞 260
日本核电站爆炸内幕
正文年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
茶点故事阅读 33,244评论 3赞 241
男人毒药：我在死后第九天来索命
文/蒙蒙一、第九天我趴在偏房一处隐蔽的房顶上张望。院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
开封第一讲书人阅读 26,146评论 0赞 8
一桩弑父案，背后竟有这般阴谋
文/苍兰香墨我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。一阵脚步声响...
开封第一讲书人阅读 26,949评论 0赞 201
情欲美人皮
我被黑心中介骗来泰国打工，没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。一个月前我还...
沈念sama阅读 35,995评论 2赞 285
代替公主和亲
正文我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
茶点故事阅读 35,812评论 2赞 276

GCD的高级用法

一次性执行(dispatch_once_t)

延时操作

调度组(Dispatch_groups)

用法一

用法二

用法三(平时开发最常用)

dispatch_barrier

dispatch_apply

并行队列

串行队列

推荐阅读更多精彩内容