GCD

简介

什么是GCD
全称是Grand Central Dispatch，可译为“牛逼的中枢调度器”
纯C语言，提供了非常多强大的函数

GCD的优势
GCD是苹果公司为多核的并行运算提出的解决方案
GCD会自动利用更多的CPU内核（比如双核、四核）
GCD会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
程序员只需要告诉GCD想要执行什么任务，不需要编写任何线程管理代码

任务和队列

GCD中有2个核心概念
任务：执行什么操作
队列：用来存放任务

GCD的使用就2个步骤
定制任务,确定想做的事情

将任务添加到队列中
GCD会自动将队列中的任务取出，放到对应的线程中执行
任务的取出遵循队列的FIFO原则：先进先出，后进后出

执行任务

GCD中有2个用来执行任务的常用函数
用同步的方式执行任务

dispatch_sync(dispatch_queue_t queue, dispatch_block_t block);// queue：队列// block：任务

用异步的方式执行任务

dispatch_async(dispatch_queue_t queue, dispatch_block_t block);

同步和异步的区别
同步：只能在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力

GCD中还有个用来执行任务的函数：

dispatch_barrier_async(dispatch_queue_t queue, dispatch_block_t block);

在前面的任务执行结束后它才执行，而且它后面的任务等它执行完成之后才会执行
但是这个queue不能是全局的并发队列

队列的类型

GCD的队列可以分为2大类型
并发队列（Concurrent Dispatch Queue）
可以让多个任务并发（同时）执行（自动开启多个线程同时执行任务）
并发功能只有在异步（dispatch_async）函数下才有效

串行队列（Serial Dispatch Queue）
让任务一个接着一个地执行（一个任务执行完毕后，再执行下一个任务）

容易混淆的术语

有4个术语比较容易混淆：同步、异步、并发、串行
同步和异步主要影响：能不能开启新的线程
同步：只是在当前线程中执行任务，不具备开启新线程的能力
异步：可以在新的线程中执行任务，具备开启新线程的能力

并发和串行主要影响：任务的执行方式
并发：允许多个任务并发（同时）执行
串行：一个任务执行完毕后，再执行下一个任务

并发队列

使用dispatch_queue_create函数创建队列

dispatch_queue_tdispatch_queue_create(const char *label, // 队列名称 dispatch_queue_attr_t attr); // 队列的类型：串行或者并发

创建并发队列

dispatch_queue_t queue = dispatch_queue_create("concurrent.queue", DISPATCH_QUEUE_CONCURRENT);

GCD默认已经提供了全局的并发队列，供整个应用使用，可以无需手动创建
使用dispatch_get_global_queue函数获得全局的并发队列

dispatch_queue_t dispatch_get_global_queue(dispatch_queue_priority_t priority, // 队列的优先级unsigned long flags); // 此参数暂时无用，用0即可

获得全局并发队列

dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); 

全局并发队列的优先级

#define DISPATCH_QUEUE_PRIORITY_HIGH 2 // 高#define DISPATCH_QUEUE_PRIORITY_DEFAULT 0 // 默认（中）#define DISPATCH_QUEUE_PRIORITY_LOW (-2) // 低#define DISPATCH_QUEUE_PRIORITY_BACKGROUND INT16_MIN // 后台

串行队列

GCD中获得串行有2种途径
使用dispatch_queue_create函数创建串行队列

// 创建串行队列（队列类型传递NULL或者DISPATCH_QUEUE_SERIAL）dispatch_queue_t queue = dispatch_queue_create("serial.queue", NULL); 

使用主队列（跟主线程相关联的队列）
主队列是GCD自带的一种特殊的串行队列
放在主队列中的任务，都会放到主线程中执行
使用dispatch_get_main_queue()获得主队列

dispatch_queue_t queue = dispatch_get_main_queue();

各种队列的执行效果

注意
使用sync函数往当前串行队列中添加任务，会卡住当前的串行队列(死锁)

线程间通信示例

// 从子线程回到主线程dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{    // 执行耗时的异步操作...      dispatch_async(dispatch_get_main_queue(), ^{        // 回到主线程，执行UI刷新操作        });});

GCD常用函数

1. 延时执行

// iOS常见的延时执行// 调用NSObject的方法[self performSelector:@selector(run) withObject:nil afterDelay:2.0];// 2秒后再调用self的run方法// 使用GCD函数dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{    // 2秒后执行这里的代码...});// 使用NSTimer[NSTimer scheduledTimerWithTimeInterval:2.0 target:self selector:@selector(test) userInfo:nil repeats:NO];

2. 一次性执行

使用dispatch_once函数能保证某段代码在程序运行过程中只被执行1次

static dispatch_once_t onceToken;dispatch_once(&onceToken, ^{    // 只执行1次的代码(这里面默认是线程安全的)});

3. GCD定时器

#pragma mark - GCD定时器- (void)gcdTimer{    // GCD定时器相比于NSTimer使用起来较麻烦, 但是比NSTimer准确    // 1. 创建一个队列    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);    // 2. 创建一个定时器(需要强引用)    self.timer = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);    // 3. 设置定时器(间隔的时间单位是纳秒, 所以设置间隔事件的时候需要乘以NSEC_PER_SEC, 也就是10的9次方纳秒)    dispatch_time_t start = dispatch_time(DISPATCH_TIME_NOW, (int64_t)3.0 * NSEC_PER_SEC);    uint64_t interval = 2.0 * NSEC_PER_SEC;    dispatch_source_set_timer(self.timer, start, interval, 0);    // 4. 设置回调(相当于NSTimer的SEL)    dispatch_source_set_event_handler(self.timer, ^{        NSLog(@"gcd timer event handler...");    });    // 5. 启动定时器    dispatch_resume(self.timer);}

4. 快速迭代

使用dispatch_apply函数能进行快速迭代遍历

dispatch_apply(10, dispatch_get_global_queue(0, 0), ^(size_t index){    // 执行10次代码，index顺序不确定});

5. 队列组Group

有这么1种需求
首先：分别异步执行2个耗时的操作
其次：等2个异步操作都执行完毕后，再回到主线程执行操作

如果想要快速高效地实现上述需求，可以考虑用队列组

dispatch_group_t group =  dispatch_group_create();dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{    // 执行1个耗时的异步操作});dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{    // 执行1个耗时的异步操作});dispatch_group_notify(group, dispatch_get_main_queue(), ^{    // 等前面的异步操作都执行完毕后，回到主线程...});

dispatch_group合成头像

之前的项目里有一个需求，就是获取到群里的成员，用他们的头像合成一张群头像，代码如下：

#pragma mark - dispatch_group -- 合成头像- (void)dispatchGroup{    // 创建一个组    dispatch_group_t group = dispatch_group_create();    // 全局队列    dispatch_queue_t queue = dispatch_get_global_queue(0, 0);    // 下载头像1    dispatch_group_async(group, queue, ^{        NSString *avatarUrlStr = @"http://file03.16sucai.com/2016/01/2016m0vqvlsppel.jpg";        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:avatarUrlStr]];        self.avatar1 = [UIImage imageWithData:data];    });    // 下载头像2    dispatch_group_async(group, queue, ^{        NSString *avatarUrlStr = @"http://f.hiphotos.baidu.com/zhidao/wh%3D600%2C800/sign=bef3cd5ab3119313c716f7b6550820ef/0b7b02087bf40ad18f69c47b562c11dfa8ecce9d.jpg";        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:avatarUrlStr]];        self.avatar2 = [UIImage imageWithData:data];    });    // 下载头像3    dispatch_group_async(group, queue, ^{        NSString *avatarUrlStr = @"http://img3.duitang.com/uploads/item/201601/06/20160106232923_CAYyi.png";        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:avatarUrlStr]];        self.avatar3 = [UIImage imageWithData:data];    });    // 下载头像4    dispatch_group_async(group, queue, ^{        NSString *avatarUrlStr = @"http://file03.16sucai.com/2016/01/2016wjj3d1d5lpo.jpg";        NSData *data = [NSData dataWithContentsOfURL:[NSURL URLWithString:avatarUrlStr]];        self.avatar4 = [UIImage imageWithData:data];    });    // 当组里的所有任务都执行完毕后会通知dispatch_group_notify执行里面的任务    dispatch_group_notify(group, queue, ^{        [self composeAvatar];    });}// 合成头像- (void)composeAvatar{    // 1. 打开图形上下文, 获取到图形上下文, 并设置合成后的图片大小    UIGraphicsBeginImageContext(CGSizeMake(200, 200));    // 2. 把四张头像都画到新的图片上    [self.avatar1 drawInRect:CGRectMake(0, 0, 100, 100)];    [self.avatar2 drawInRect:CGRectMake(100, 0, 100, 100)];    [self.avatar3 drawInRect:CGRectMake(0, 100, 100, 100)];    [self.avatar4 drawInRect:CGRectMake(100, 100, 100, 100)];    // 3. 合成后的头像    UIImage *avatarImage = UIGraphicsGetImageFromCurrentImageContext();    // 4. 关闭图形上下文    UIGraphicsEndImageContext();    // 5. 回到主线程显示合成后的头像    dispatch_async(dispatch_get_main_queue(), ^{        self.avatarImageView.image = avatarImage;    });}

头像合成效果如下：

5. 栅栏

#pragma mark - 栅栏- (void)barrierAsync {    // 执行结果: dispatch_barrier_async起到了一个栅栏作用(阻塞分隔),异步任务1和异步任务2先执行完毕才会到dispatch_barrier_async任务执行, 等dispatch_barrier_async任务执行完毕才会接着执行异步任务3和异步任务4，    // 注意:dispatch_barrier_async只有在手动创建的并行队列中才会有效（在全局并发队列中无效）    // dispatch_barrier_sync 也能达到同样效果， 但是dispatch_barrier_sync是在主线程中执行    // 创建一个并行队列    dispatch_queue_t queue = dispatch_queue_create("async.concurrent", DISPATCH_QUEUE_CONCURRENT);    dispatch_async(queue, ^{        NSLog(@"异步任务1 = %@", [NSThread currentThread]);    });    dispatch_async(queue, ^{        NSLog(@"异步任务2 = %@", [NSThread currentThread]);    });    dispatch_barrier_async(queue, ^{         NSLog(@"==================== 华丽的分割线 ====================");    });    dispatch_async(queue, ^{        NSLog(@"异步任务3 = %@", [NSThread currentThread]);    });    dispatch_async(queue, ^{        NSLog(@"异步任务4 = %@", [NSThread currentThread]);    });}

单例模式

单例模式的作用
可以保证在程序运行过程，一个类只有一个实例，而且该实例易于供外界访问，从而方便地控制了实例个数，并节约系统资源

单例模式的使用场合
在整个应用程序中，共享一份资源（这份资源只需要创建初始化1次）

在.m中保留一个全局的static的实例

static id _instance;

提供1个类方法让外界访问唯一的实例

+ (instancetype)sharedInstance{    static dispatch_once_t onceToken;    dispatch_once(&onceToken, ^{        _instance = [[self alloc] init];    });    return _instance;}

同步、异步、串行、并行执行可以有以下几种组合：

#pragma mark - 异步并发- (void)asyncConcurrent {    // 执行结果: 会开启多条子线程, 并发执行    // GCD的好处:提高多核CPU的使用效率    // 最多能开启多少个子线程，这由CPU决定，但是开启多个子线程是会消耗性能的    // 创建一个并行队列    dispatch_queue_t queue = dispatch_queue_create("async.concurrent", DISPATCH_QUEUE_CONCURRENT);    dispatch_async(queue, ^{        NSLog(@"异步并发1 = %@", [NSThread currentThread]);    });    dispatch_async(queue, ^{        NSLog(@"异步并发2 = %@", [NSThread currentThread]);    });    dispatch_async(queue, ^{        NSLog(@"异步并发3 = %@", [NSThread currentThread]);    });}#pragma mark - 异步串行- (void)asyncSerial{    // 执行结果: 会开启一条子线程, 串行执行    // 如果串行队列是自己创建的, 那么在异步任务下会开启一条子线程, 串行执行    // 串行队列    dispatch_queue_t queue = dispatch_queue_create("async.serial", DISPATCH_QUEUE_SERIAL);    dispatch_async(queue, ^{        NSLog(@"异步串行1 currentThread = %@", [NSThread currentThread]);    });    dispatch_async(queue, ^{        NSLog(@"异步串行2 currentThread = %@", [NSThread currentThread]);    });    dispatch_async(queue, ^{        NSLog(@"异步串行3 currentThread = %@", [NSThread currentThread]);    });}#pragma mark - 异步+主队列- (void)asyncMainQueue{    // 执行结果: 在主线程中串行执行    // 如果队列是主队列, 则是串行执行, 即使是异步, 也不会开启新的线程    // 主队列    dispatch_queue_t queue = dispatch_get_main_queue();    dispatch_async(queue, ^{        NSLog(@"异步+主队列1 currentThread = %@", [NSThread currentThread]);    });    dispatch_async(queue, ^{        NSLog(@"异步+主队列2 currentThread = %@", [NSThread currentThread]);    });    dispatch_async(queue, ^{        NSLog(@"异步+主队列3 currentThread = %@", [NSThread currentThread]);    });}#pragma mark - 同步并发- (void)syncConcurrent{    // 执行结果: 串行执行, 不会开启子线程    // 由于是同步, 是在当前线程里执行任务, 并不会开启子线程, 所以并行队列并不会有什么用, 最终还是同步串行执行任务    // 全局并发队列：第一个参数是优先级, 第二个参数是保留参数, 暂时没有用处, 写0即可    dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);    dispatch_sync(queue, ^{        NSLog(@"同步并发1 currentThread = %@", [NSThread currentThread]);    });    dispatch_sync(queue, ^{        NSLog(@"同步并发2 currentThread = %@", [NSThread currentThread]);    });    dispatch_sync(queue, ^{        NSLog(@"同步并发3 currentThread = %@", [NSThread currentThread]);    });}#pragma mark - 同步串行- (void)syncSerial{    // 执行结果: 同步执行    // 同步任务下不会开启新线程, 并且是串行执行任务    // 串行队列    dispatch_queue_t queue = dispatch_queue_create("async.serial", DISPATCH_QUEUE_SERIAL);    dispatch_sync(queue, ^{        NSLog(@"同步串行1 currentThread = %@", [NSThread currentThread]);    });    dispatch_sync(queue, ^{        NSLog(@"同步串行2 currentThread = %@", [NSThread currentThread]);    });    dispatch_sync(queue, ^{        NSLog(@"同步串行3 currentThread = %@", [NSThread currentThread]);    });}