iOS多线程之GCD
GCD(Grand Central Dispatch)是基于C语言开发的一套多线程开发机制
1.GCD的优势：
- GCD 可用于多核的并行运算
- GCD 会自动利用更多的 CPU 内核（比如双核、四核）
- GCD 会自动管理线程的生命周期（创建线程、调度任务、销毁线程）
- 程序员只需要告诉 GCD 想要执行什么任务，不需要编写任何线程管理代码
2. GCD 任务和队列：
任务：就是执行操作的意思，换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的。
执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。
- 同步执行（sync）：
- 同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
- 只能在当前线程中执行任务，不具备开启新线程的能力。
- 异步执行（async）：
- 异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
- 可以在新的线程中执行任务，具备开启新线程的能力。
队列（Dispatch Queue）：这里的队列指执行任务的等待队列，即用来存放任务的队列。队列是一种特殊的线性表，采用 FIFO（先进先出）的原则，即新任务总是被插入到队列的末尾，而读取任务的时候总是从队列的头部开始读取。每读取一个任务，则从队列中释放一个任务。
在 GCD 中有两种队列：串行队列和并行队列。两者都符合 FIFO（先进先出）的原则。两者的主要区别是：执行顺序不同，以及开启线程数不同。
-
串行队列（Serial Dispatch Queue）：
- 每次只有一个任务被执行。让任务一个接着一个地执行。（只开启一个线程，一个任务执行完毕后，再执行下一个任务）
-
并行队列（Concurrent Dispatch Queue）：
- 可以让多个任务并发（同时）执行。（可以开启多个线程，并且同时执行任务）
注意：并行队列的并行功能只有在异步（dispatch_async）函数下才有效
主队列同步执行死锁原因：
- (void)viewDidLoad {
[super viewDidLoad];
dispatch_sync(dispatch_get_main_queue(), ^{
NSLog(@"123");
});
}
解释：主队列中的viewDidLoad和block依据先进先出的顺序进行，
viewDidLoad的完成需要block的执行，
block的执行又需要等待viewDidLoad的执行完成，相互等待，造成死锁
3.GCD常用方法
3.1栅栏方法：dispatch_barrier_async
如果我们需要执行两组异步动作，且第二组需要在第一组全部完成以后才开始，这样我们就需要用到dispatch_barrier_async在两个操作组间形成栅栏。
dispatch_barrier_async函数会等待前边追加到并行队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行
# 下面代码会先并发执行任务1、2，均执行完后再执行barrier任务
# 待barrier任务执行完毕， 会接着并发执行3、4
- (void)barrier {
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(queue, ^{
// 追加任务1
});
dispatch_async(queue, ^{
// 追加任务2
});
dispatch_barrier_async(queue, ^{
// barrier任务
});
dispatch_async(queue, ^{
// 追加任务3
});
dispatch_async(queue, ^{
// 追加任务4
});
}
栅栏dispatch_barrier_async的使用场景：
1). 解决网络请求依赖，比如一个接口的请求需要依赖于另一个网络请求的结果
2). 解决多读单写，要求：
- 读者之间并发
- 读者、写着之间互斥
- 写者之间互斥
// 声明一个队列
@property (nonatomic, strong) dispatch_queue_t concurrent_t;
// 创建并行队列
self.concurrent_t = dispatch_queue_create("com.zmj", DISPATCH_QUEUE_CONCURRENT);
#objectForKey方法: 采用同步方式，可以保证立刻得到返回值；
# 提交到并发队列，可以保证并发执行多个读取操作。
- (id)objectForKey:(NSString *)key {
__block id obj = nil;
// 同步读取指定数据
dispatch_sync(self.concurrent_t, ^{
obj = [self.dic objectForKey: key];
});
return obj;
}
#setObject forKey方法: 采用GCD栅栏,保证写与写之间互斥
#同时写的栅栏隔离了读取操作，保证了读与写之间互斥
- (void)setObject:(id)obj forKey:(NSString *)key {
// 异步栅栏 设置数据
dispatch_barrier_async(self.concurrent_t, ^{
[self.dic setObject: obj forKey: key];
});
}
3.2dispatch_after延迟执行
dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到队列中。
这个时间并不是绝对准确的。
dispatch_time_t time = dispatch_time(DISPATCH_TIME_NOW, 3*NSEC_PER_SEC);
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_after(time, queue, ^{
NSLog(@"3秒后添加到队列");
});
#注意：相比于GCD方式，performSelector:withObject:afterDelay:有可能不会被调用到
比如：
dispatch_queue_t t = dispatch_queue_create("这是并发队列", DISPATCH_QUEUE_CONCURRENT);
dispatch_async(t, ^{
//这个selector不会执行，因为线程中没有runloop,只有主线程会默认创建runloop
[self performSelector:@selector(testDelay) withObject:nil afterDelay:3];
// 解决方法：开启当前线程的runloop
// [[NSRunLoop currentRunLoop] run];
});
3.3dispatch_once只执行一次
dispatch_once():函数能保证某段代码在程序运行过程中只被执行1次，重复调用也没办法重复执行（单例模式中常用此方法）并且即使在多线程的环境下，dispatch_once也可以保证线程安全。
- (void)once {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
}
3.4dispatch_apply重复执行
dispatch_apply按照指定的次数将指定的任务追加到指定的队列中，并等待全部队列执行结束。
如果是在串行队列中使用dispatch_apply，那么就和 for 循环一样，按顺序同步执行。
为了不阻塞线程可以使用并发队列dispatch_async来达到异步执行的目的。
还有一点，无论是在串行队列，还是并行队列中，dispatch_apply都会等待全部任务执行完毕，这点就像是同步操作，也像是队列组中的 dispatch_group_wait方法。
//生成全局队列
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
# 该函数按指定的次数将指定的Block追加到指定的Dispatch Queue中,并等到全部的处理执行结束
# @param 10 指定重复次数 指定10次
# @param queue 追加对象的Dispatch Queue
# @param index 带有参数的Block, index的作用是为了按执行的顺序区分各个Block
NSLog(@"begin");
dispatch_apply(10, queue, ^(size_t index) {
NSLog(@"%zd",index);
});
NSLog(@"end");
3.5 GCD 队列组：dispatch_group
3.5.1 队列组之dispatch_group_notify
监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。
dispatch_queue_t disqueue = dispatch_queue_create("myQueue", DISPATCH_QUEUE_CONCURRENT);
dispatch_group_t disgroup = dispatch_group_create();
dispatch_group_async(disgroup, disqueue, ^{
NSLog(@"1");
});
dispatch_group_async(disgroup, disqueue, ^{
NSLog(@"2");
});
dispatch_group_notify(disgroup, disqueue, ^{
NSLog(@"notify");
});
# 打印顺序： 1、2、notify
3.5.2 队列组之dispatch_group_wait
暂停当前线程（阻塞当前线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。
- (void)groupWait {
NSLog(@"begin");
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), ^{
// 追加任务2
});
// 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"end");
}
# 打印顺序： 1、2顺序不定，因为是并发执行，end在最后
3.5.3 队列组之dispatch_group_enter和dispatch_group_leave
-
dispatch_group_enter标志着一个任务追加到 group，执行一次，相当于 group 中未执行完毕任务数+1 -
dispatch_group_leave标志着一个任务离开了 group，执行一次，相当于 group 中未执行完毕任务数-1。 - 当 group 中未执行完毕任务数为0的时候，才会使
dispatch_group_wait解除阻塞，以及执行追加到dispatch_group_notify中的任务。
- (void)groupEnterAndLeave {
dispatch_group_t group = dispatch_group_create();
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务1
dispatch_group_leave(group);
});
dispatch_group_enter(group);
dispatch_async(queue, ^{
// 追加任务2
dispatch_group_leave(group);
});
// 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
dispatch_group_wait(group, DISPATCH_TIME_FOREVER);
NSLog(@"wait_end");
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步操作都执行完毕后，回到主线程.
NSLog(@"notify_end");
});
}
# 打印顺序：任务1、2顺序不定，然后wait_end, 最后notify_end
这里的dispatch_group_enter、dispatch_group_leave组合，其实等同于前面的dispatch_group_async。
3.6dispatch_semaphore信号量
GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。
在 Dispatch Semaphore 中，计数为0时等待，不可通过；计数为1或大于1时，计数减1且不等待，可通过。
-
dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量 -
dispatch_semaphore_signal：发送一个信号，让信号总量加1 -
dispatch_semaphore_wait：可以使总信号量减1，当信号总量为0时就会一直等待（阻塞所在线程），否则就可以正常执行。
Dispatch Semaphore 在实际开发中主要用于：
- 保持线程同步，将异步执行任务转换为同步执行任务
- 保证线程安全，为线程加锁
3.6.1 Semaphore保持线程同步
我们在开发中，会遇到这样的需求：异步执行耗时任务，并使用异步执行的结果进行一些额外的操作。换句话说，相当于，将将异步执行任务转换为同步执行任务。
- (void)semaphoreSync {
NSLog(@"semaphore---begin");
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
__block int number = 0;
dispatch_async(queue, ^{
// 追加任务1 模拟耗时操作
number = 100;
dispatch_semaphore_signal(semaphore);
});
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
NSLog(@"semaphore---end");
}
3.6.2 Semaphore线程安全
场景：总共有50张火车票，有两个售卖火车票的窗口，一个是北京火车票售卖窗口，另一个是上海火车票售卖窗口。两个窗口同时售卖火车票，卖完为止。
- (void)initTicketStatusSave {
NSLog(@"semaphore---begin");
semaphoreLock = dispatch_semaphore_create(1);
self.ticketSurplusCount = 50;
// queue1 代表北京火车票售卖窗口
dispatch_queue_t queue1 = dispatch_queue_create("net.bujige.testQueue1", DISPATCH_QUEUE_SERIAL);
// queue2 代表上海火车票售卖窗口
dispatch_queue_t queue2 = dispatch_queue_create("net.bujige.testQueue2", DISPATCH_QUEUE_SERIAL);
__weak typeof(self) weakSelf = self;
dispatch_async(queue1, ^{
[weakSelf saleTicketSafe];
});
dispatch_async(queue2, ^{
[weakSelf saleTicketSafe];
});
}
// 售卖火车票(线程安全)
- (void)saleTicketSafe {
while (1) {
// 相当于加锁
dispatch_semaphore_wait(semaphoreLock, DISPATCH_TIME_FOREVER);
if (self.ticketSurplusCount > 0) { //如果还有票，继续售卖
self.ticketSurplusCount--;
// 相当于解锁
dispatch_semaphore_signal(semaphoreLock);
} else { //如果已卖完，关闭售票窗口
// 相当于解锁
dispatch_semaphore_signal(semaphoreLock);
break;
}
}
}
GCD常见面试题
下面代码会死锁吗，如果不会执行顺序是？
- (void)test {
dispatch_queue_t global_t = dispatch_get_global_queue(0, DISPATCH_QUEUE_PRIORITY_DEFAULT);
NSLog(@"1");
dispatch_sync(global_t, ^{
NSLog(@"2");
dispatch_sync(global_t, ^{
NSLog(@"3");
});
NSLog(@"4");
});
NSLog(@"5");
}
答案：
1.只要是以同步方式提交任务，不论是串行还是并发，都是在当前线程（多是主线程）执行
2.提交到全局（并发）队列的任务，全局（并发）队列可以并发执行任务，所以不会跟上面一样造成死锁
