iOS学习笔记-----GCD 用法介绍

GCD(Grand Central Dispatch)

简介

Apple提供的一套更底层、更高效的并发编程技术,纯C语言、基于Block

支持同步或异步任务处理,串行、并行的处理队列,非系统调用的信号量机制,定时任务处理,进程、文件或网络的监听任务等

优点

易用:GCD比之thread更简单易用。基于block的特性导致它能极为简单得在不同代 码作用域之间传递上下文

效率:GCD实现功能 轻量、优雅,使得它在很多地方比之专门创建消耗资源的线程 更实用且快速

性能:GCD自动根据系统负载来增减线程数量,这就减少了上下文切换以及增加了计 算效率

安全:无需加锁或其他同步机制

Dispatch Queue

两种队列

Dispatch Queue是执行处理的等待队列。通过dispatch_async等函数, 按照先进先出(FIFO)顺序追加到Queue中处理,执行处理时,存在两种 Dispatch Queue:

Serial Dispatch Queue :

串行队列,一个线程同时执行一个任务,可以避免数据竞争的问题

可以生成多个 Serial Dispatch Queue,各个 Serial Dispatch Queue 将并行执行

Concurrent Dispatch Queue :

并发队列,多个线程同时执行多个任务,效率高,具体是多少个线程并发执行,取决于CPU核数和CPU负荷

主队列与全局队列

Main Dispatch Queue

主队列,在主线程里执行的队列。因为主线程只有一个,所以 Main Dispatch Queue 自然就是 Serial Dispatch Queue.

一切跟UI有关的操作必须放在主线程中执行,所以要追加到Main Dispatch Queue.

(dispatch_get_main_queue)

Global Dispatch Queue

全局队列,所有应用程序都能够使用的 Concurrent Dispatch Queue.

(dispatch_get_global_queue)

GCD使用

1.两种任务添加方式

dispatch_async 异步添加

提交一个异步执行的 block块 到队列里面并且直接返回,不用等待

block 被调用

dispatch_sync 同步添加

提交一个同步执行的 block块 到队列里面并且等待,直到这个 block 执行完成,与 dispatch_async 相反

注:使用 dispatch_sync 容易引起死锁,慎重使用。比如在主线程里面执行 往主队列里面添加 任务 的操作就会引起死锁

2.使用GCD简单实现UIImageView异步加载图片

创建类目

自定义方法

- (void)setImageWithURL:(NSURL *)url {

//创建串行队列
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);

//依次将两个任务 异步的添加到串行队列中
//局部变量 只有添加了__blcok 才能在block中被修改
__block UIImage *image = nil;
//开启多线程 加载网络图片
dispatch_async(queue, ^{
//从网络读取数据
NSData *data = [NSData dataWithContentsOfURL:url];
image = [UIImage imageWithData:data];
});
//回到主线程 显示图片到视图中
dispatch_async(queue, ^{
//重新获取主队列，并且将显示图片的操作，添加到主队列执行
dispatch_queue_t mainQueue = dispatch_get_main_queue();
//向主队列中添加界面刷新操作
dispatch_async(mainQueue, ^{
self.image = image;
});

});

}

3.延迟任务 dispatch_after

/*  获取某一个时间点
*  @param when    参照时间   DISPATCH_TIME_NOW = 当前时间点
*  @param delta   时间差 纳秒为单位的时间  NSEC_PER_SEC = 1秒
*  @return 时间点
*/
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 3);

//延时调用异步任务
dispatch_after(time, dispatch_get_main_queue(), ^{
NSLog(@"延迟任务执行");
});

dispatch_after 和 performSelector:withObject:afterDelay: 的区别

1. 调用方式，前者使用block形式来调用，后者只能使用Selector

2. 后者能够通过cancel来取消还未开始的方法掉用，但是dispatch_after需要通过非常复杂的方法才能够来取消延迟任务。

3. dispatch_after的精确度比后者高很多

4.设置队列优先级

dispatch_set_target_queue(<#dispatch_object_t object#>, <#dispatch_queue_t queue#>);
//改变queue的优先级与目标queue相同
//可以使多个serial queue在目标queue上 一次只有一个执行(串行执行)
/*
优先级
DISPATCH_QUEUE_PRIORITY_HIGH 2     高优先级
DISPATCH_QUEUE_PRIORITY_DEFAULT 0  默认优先级
DISPATCH_QUEUE_PRIORITY_LOW (-2)   低优先级
DISPATCH_QUEUE_PRIORITY_BACKGROUND 后台执行
*/

5.挂起队列

//将队列处于悬停状态，在悬停状态的队列，无法继续执行其中的任务。但是对已经开始执行的任务，无效
//创建串行队列
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_SERIAL);
//挂起队列
dispatch_suspend(queue);
//在5秒钟之后 再进行恢复
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 5);
dispatch_after(time, dispatch_get_main_queue(), ^{
//恢复队列
dispatch_resume(queue);
});

挂起任务 dispatch_suspend

挂起(暂停)队列里面尚未开始执行的任务,对已经正在执行的任务没有影响

使 queue 的 suspension reference count 加1

恢复任务 dispatch_resume

恢复队列里面之前被挂起的任务,使这些任务能够继续执行

使 queue 的 suspension reference count 减1

注意事项

当suspension reference count大于0时,queue就保持挂起状态。因此,必须平 衡使用suspend和resume

如果挂起了一个queue或者source,那么在销毁它之前,必须先对其进行恢复

6.一次任务

保证 dispatch_once 中的代码块在应用程序里面只执行一次,无论是不是多线程。

所以可以用来实现单例模式,安全、简洁、方便。

#import "Person.h"

@implementation Person
static Person *p;
+ (instancetype)sharedPerson {

if (p == nil) {
//dispatch_once 一次任务 多用于单例对象
//使用dispatch_once执行的代码，在整个程序的运行过程中，一共只能执行一次
//onceToken 表示执行的标记
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
p = [[super allocWithZone:nil] init];
});
}

return p;
}

+ (instancetype)allocWithZone:(struct _NSZone *)zone {
if (p == nil) {
p = [Person sharedPerson];
}

return p;
}

- (id)copy {
return self;
}

@end

7.组任务

1.dispatch_group_async 监视一组block任务的完成,多个任务都结束后 的一个汇总处理,可以同步或异步地监视

2.dispatch_group_notify 所有任务执行结束汇总,不阻塞当前线程

3.dispatch_group_wait 等待直到所有任务执行结束,中途不能取消,阻塞当前线程

具体代码:

//创建队列
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//创建任务组
dispatch_group_t group = dispatch_group_create();

//1.添加任务到队列中，并且添加到任务组中
dispatch_group_async(group, globalQueue, ^{

NSLog(@"任务1开始");
[NSThread sleepForTimeInterval:3];
NSLog(@"任务1结束");
});

//2.在组中所有的任务完成后，会收到一个完成的通知，然后来调用相对应的Block
dispatch_group_notify(group, globalQueue, ^{
NSLog(@"任务已经完成");
});

//3.监控任务是否完成
//设定时间点
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, NSEC_PER_SEC * 8);
//等待  等待到某个时间点后，来查看任务的完成情况
//等待操作，会堵塞当前线程
//DISPATCH_TIME_FOREVER表示一直等待，直到所有任务都完成
long result = dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
//返回值为0  则代表所有任务完成，不为0 表示有任务没完成
if (result == 0) {
NSLog(@"所有任务已经执行完毕");
} else {
NSLog(@"还有任务没有完成,%li", result);
}

8.多元调用(迭代)

1. dispatch_apply 提交一个多元调用的block块到队列里面,并且等待block任务的所有迭代,完成之后才返回.

2. dispatch_apply 会阻塞当前线程,推荐在 dispatch_async 中执行 dispatch_apply 函数.

3. 结合concurrent queue,dispatch_apply能实现一个高性能的循环迭代.

NSMutableArray *array = [NSMutableArray arrayWithCapacity:1000];
for (int i = 0; i < 1000; i++) {
[array addObject:@(i)];
}
//多元调用（迭代）
//创建并发队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
//在全局队列中 异步的添加迭代任务
dispatch_async(queue, ^{

//多元调用
/**
*  多元调用 每一次调用之间没有顺序
*
*  @param iterations   调用次数
*  @param queue        调用所在队列  并发队列
*  @param block        每一次调用 所执行的Block
*
*/
dispatch_apply(array.count, queue, ^(size_t index) {
[NSThread sleepForTimeInterval:0.3];
NSLog(@"%@", array[index]);
NSLog(@"%@", [NSThread currentThread]);
});

});

/*
为了提高大数据量的数组遍历的速度，所以使用多元调用
for循环遍历，每一次遍历操作，串行执行。总时间 ＝ 每一次遍历的耗时 ＊ 总次数
使用多元调用，将每一次遍历，放到多线程中去。在多线程中，可以同时遍历多次，这样能够提高遍历的效率
总时间 ＝ 每一次遍历的耗时 ＊ 总次数 ／ 线程数 ＋ 线程开启关闭的时间

!!  遍历的过程，没有顺序不按照数组顺序来
*/

9.设立障碍

1.dispatch_barrier_async 提交一个异步执行的带障碍的block块到队列里面,并且直接返回.

2.使用 dispatch_barrier_async,需要指定通过dispatch_queue_create函数创建的一个concurrent queue.

3.在barrier任务之前的所有任务将并行执行,任何在此之后提交的任务将不会执行直到这个 barrier任务执行完成.

//添加障碍任务
//创建并发队列 不能使用全局队列
dispatch_queue_t queue = dispatch_queue_create("queue", DISPATCH_QUEUE_CONCURRENT);

//异步的添加任务1
dispatch_async(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"任务1 %i", i);
}
});

//异步的添加任务2
dispatch_async(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"任务2 %i", i);
}
});
//插入障碍任务
dispatch_barrier_async(queue, ^{
NSLog(@"障碍任务开始");
[NSThread sleepForTimeInterval:3];
NSLog(@"障碍任务结束");
});

//异步的添加任务3
dispatch_async(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"任务3 %i", i);
}
});

//异步的添加任务4
dispatch_async(queue, ^{
for (int i = 0; i < 10; i++) {
NSLog(@"任务4 %i", i);
}
});

//任务1,2执行完成后,要执行障碍任务,等待障碍任务完成,才能继续执行任务3,4.

10.信号量semaphore

1.dispatch_semaphore_t持有计数的信号,使用计数来实现该信号功能。计数为0时等待,计数大于等于1时, 减去1而不等待

2.dispatch_semaphore_create 创建新的计数信号

3.dispatch_semaphore_wait 信号量为0时等待,大于等于1时,减1而不等待

4.dispatch_semaphore_signal 发信号,使信号加1

//使用信号量 来设置同时访问资源的线程数
//创建队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
__block NSMutableArray *array = [[NSMutableArray alloc] init];
//创建信号量
dispatch_semaphore_t semaphore = dispatch_semaphore_create(1);

//循环插入数据
for (int i = 0; i < 100000; i++) {
dispatch_async(queue, ^{

/**
* 判断信号量 是否能够继续执行 访问公共资源
* 如果此时信号量不为0  则信号量减1，然后继续执行代码
* 信号量为0 则等待，直到时间超时或者信号量大于0
* 保证信号量为0时,其他线程不能访问
*/
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);

[array addObject:@(i)];

//公共资源访问完毕，释放信号量
dispatch_semaphore_signal(semaphore);
});
}

多线程总结

GCD pk NSOperationQueue

GCD是纯C语言的API;NSOperationQueue是基于GCD的OC版本的封装

GCD的执行速度比NSOperationQueue快

GCD只支持FIFO的队列,且任务一旦添加到队列则无法取消;NSOperationQueue 可以很方便的调整执行顺序,可以添加依赖,设置最大并发量

NSOperationQueue支持KVO,可以检测Operation的状态(执行、结束、取消)

GCD or NSOperationQueue

GCD本身非常简单、易用、效率高,对于不复杂的多线程操作,会节省代码量,而Block参数的使用,会是代码更为易读,建议在简单项目中使用

NSOperation是对线程的高度抽象,在项目中使用它,会使项目的程序结构更好,子类化NSOperation的设计思路,是具有面向对象的优点(复用、封装),使得实现是多线程支持,而接口简单,建议在复杂项目中使用

Sleep和Wait的区别

1.sleep是NSThread中的一个方法,wait是线程锁中的一个方法.

2.sleep用于线程控制,使某一个线程进入到休眠状态.wait用于线程通信,使一个线程进入到等待状态,但是当另一个线程解锁时,会唤醒当前等待的线程.

3.sleep不会释放线程,在休眠状态中,会一直占用当前线程.wait会释放当前线程,将线程空闲出来.当wait被唤醒时,会重新获取线程的控制权.