上文已经介绍了
GCD
的一些基本概念多线程操作之GCD概述
GCD 的使用步骤
- 创建一个队列(串行队列或并发队列)
- 将任务追加到任务的等待队列中,然后系统会根据任务类型执行任务(同步执行或异步执行)
1.队列的创建
可以使用dispatch_queue_create
来创建队列,需要传入两个参数,参数一表示:队列的唯一标识符,用于 DEBUG
,可为空;参数二:用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL
表示串行队列,DISPATCH_QUEUE_CONCURRENT
表示并发队列。
// 串行队列
dispatch_queue_t serialQueue = dispatch_queue_create("xxx", DISPATCH_QUEUE_SERIAL);
// 并发队列
dispatch_queue_t concurrentQueue = dispatch_queue_create("xxx", DISPATCH_QUEUE_CONCURRENT);
- 对于串行队列,
GCD
提供了一个特殊的串行队列,主队列Main Dispatch Queue
- 所有放在主队列中的任务,都会放到主线程中执行,不会开辟新的线程。
- 可使用
dispatch_get_main_queue()
获得主队列。
//主队列的获取方法
dispatch_get_main_queue()
- 对于并发队列,
GCD
默认提供了全局并发队列
- 可以使用
dispatch_get_global_queue
来获取。参数一:表示队列优先级,一般用DISPATCH_QUEUE_PRIORITY_DEFAULT
或者0
,参数二: 一般用0
即可
//全局并发队列的获取方法
dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
2. 任务的创建
-
GCD
提供了同步执行任务的创建方法为:dispatch_sync
- 异步执行任务的创建方法为:
dispatch_async
// 同步执行任务创建方法
dispatch_sync(queue, ^{
// 这里放同步执行任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
// 这里放异步执行任务代码
});
在这里可以看出,执行任务的时候需要添加相应的队列(串行队列or
并发队列);组合起来就有四种不同的方式:
- 同步执行 + 并发队列
- 异步执行 + 并发队列
- 同步执行 + 串行队列
- 异步执行 + 串行队列
注意这里还有上面说的两种队列:全局并发队列和主队列。全局并发队列可以作为普通并发队列来使用。但是主队列因为有点特殊,加一起就6
种不同的组合方式了
- 同步执行 + 主队列
- 异步执行 + 主队列
3.GCD
的基本使用
先来讲讲并发队列的两种执行方式。
3.1 同步执行 + 并发队列
在当前线程中执行任务,不会开启新线程,执行完一个任务之后再执行下一个任务。
/**
* 同步执行 + 并发队列
* 特点:在当前线程中执行任务,不会开启新线程,执行完一个任务,再执行下一个任务。
*/
- (void)syncConcurrent {
NSLog(@"currentThread--->%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"--->begin");
dispatch_sync(self.concurrentQueue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"1--->%@",[NSThread currentThread]);
}
});
dispatch_sync(self.concurrentQueue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"2--->%@",[NSThread currentThread]);
}
});
NSLog(@"--->end");
}
输出结果
currentThread--->{number = 1, name = main}
--->begin
1--->{number = 1, name = main}
1--->{number = 1, name = main}
2--->{number = 1, name = main}
2--->{number = 1, name = main}
--->end
从同步执行 + 并发队列中可看到:
- 所有任务都在当前线程(主线程)中执行,没有开启新的线程(同步执行不具备开启新线程的能力)
- 所有任务都在打印的
---begin
和---end
之间执行的(同步任务需要等待队列的任务执行结束,才能执行下一个) - 任务按顺序执行的。不能同时被执行。按顺序执行的原因:虽然 并发队列可以开启多个线程,并且同时执行多个任务。但是因为本身不能创建新线程,只有当前线程这一个线程(同步任务不具备开启新线程的能力),所以也就不存在并发。而且当前线程只有等待当前队列中正在执行的任务执行完毕之后,才能继续接着执行下面的操作(同步任务需要等待队列的任务执行结束)。所以任务只能一个接一个按顺序执行,不能同时被执行。
3.2 异步执行 + 并发队列
可以开启多个线程,任务交替(同时)执行。
/**
* 异步执行 + 并发队列
* 特点:可以开启多个线程, 任务交替 (同时) 执行。
*/
- (void)asyncConcurrent {
// 打印当前线程
NSLog(@"currentThread--->%@",[NSThread currentThread]);
NSLog(@"--->>begin");
dispatch_async(self.concurrentQueue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"1--->%@",[NSThread currentThread]);
}
});
dispatch_async(self.concurrentQueue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"2--->%@",[NSThread currentThread]);
}
});
NSLog(@"--->end");
}
输出结果
currentThread--->{number = 1, name = main}
--->>begin
--->end
1--->{number = 3, name = (null)}
2--->{number = 4, name = (null)}
2--->{number = 4, name = (null)}
1--->{number = 3, name = (null)}
从异步执行+并发队列中可以看出
- 除了当前线程(主线程),系统又新开启了几个新线程,并且任务是 同时/交替 执行的(异步执行具备开启新线程的能力,且并发队列可开启多个线程,同时执行多个任务)
- 所有任务都是从打印
---begin
和---end
之后才执行的,说明当前线程没有等待,而是直接开启了新的线程,在新线程中执行任务(异步执行不做等待,可以继续执行任务)
接下来再来说说串行队列的两种执行方式。
3.3 同步执行 + 串行队列
不会开启新线程,在当前线程执行任务。任务是串行的,执行完一个任务,再执行下一个任务。
/*
* 同步执行 + 串行队列
* 特点: 不会开启新线程,在当前线程执行任务。任务是串行的,执行完一个任务,再执行下一个任务。
*/
- (void)syncSerial {
// 打印当前线程
NSLog(@"currentThread--->%@",[NSThread currentThread]);
NSLog(@"--->begin");
dispatch_sync(self.serialQueue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"1--->%@",[NSThread currentThread]);
}
});
dispatch_sync(self.serialQueue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"2--->%@",[NSThread currentThread]);
}
});
NSLog(@"--->end");
}
输出结果
currentThread--->{number = 1, name = main}
--->begin
1--->{number = 1, name = main}
1--->{number = 1, name = main}
2--->{number = 1, name = main}
2--->{number = 1, name = main}
--->end
从同步执行 + 串行队列可以看到:
- 和 同步执行 + 并发队列类似
- 所有任务都在当前线程(主线程)中执行,没有开启新的线程(同步执行不具备开启新线程的能力)
- 所有任务都在打印的
---begin
和---end
之间执行的(同步任务需要等待队列的任务执行结束,才能执行下一个) - 任务按顺序执行的,只能一个接一个按顺序执行(串行队列每次只有一个任务被执行,任务一个接一个按顺序执行)
3.4 异步执行 + 串行队列
会开启新线程,但是因为任务是串行的,执行完一个任务,再执行下一个任务
/**
* 异步执行 + 串行队列
* 特点:会开启新线程,但是因为任务是串行的,执行完一个任务,再执行下一个任务。
*/
- (void)asyncSerial {
// 打印当前线程
NSLog(@"currentThread--->%@",[NSThread currentThread]);
NSLog(@"--->begin");
dispatch_async(self.serialQueue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"1--->%@",[NSThread currentThread]);
}
});
dispatch_async(self.serialQueue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"2--->%@",[NSThread currentThread]);
}
});
NSLog(@"--->end");
}
输出结果
currentThread--->{number = 1, name = main}
--->begin
--->end
1--->{number = 4, name = (null)}
1--->{number = 4, name = (null)}
2--->{number = 4, name = (null)}
2--->{number = 4, name = (null)}
在异步执行 + 串行队列中可以看到:
- 只开启了一个新线程(异步执行具备开启新线程的能力,串行队列只开启一个线程)。
- 所有任务都在打印的
---begin
和---end
之后执行的(异步执行不需要任何等待,可以继续执行任务) - 任务是按顺序执行的(串行队列每次只有一个任务被执行,任务一个接一个按顺序执行)。
主队列
主队列是
GCD
自带的一种特殊的串行队列
我们再来看看主队列的两种组合方式。
3.5 同步执行 + 主队列
同步执行 + 主队列 在不同线程中调用结果也是不一样,在主线程中调用会出现 死锁 ,而在其他线程中则不会。
3.5.1 在主线程中调用 同步执行 + 主队列
互相等待卡住不可行
/**
* 同步执行 + 主队列
* 特点(主线程调用):互等卡主不执行。
* 特点(其他线程调用):不会开启新线程,执行完一个任务,再执行下一个任务。
*/
- (void)syncMain {
// 打印当前线程
NSLog(@"currentThread--->%@",[NSThread currentThread]);
NSLog(@"--->begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_sync(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"1--->%@",[NSThread currentThread]);
}
});
dispatch_sync(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"2--->%@",[NSThread currentThread]);
}
});
NSLog(@"--->end");
}
输出结果
currentThread--->{number = 1, name = main}
--->begin
(lldb)
在同步执行 + 主队列中可以发现
- 在主线程中使用
同步执行 + 主队列
,追加到主线程的任务1
、任务2
都不再执行了,而且--end
也没有打印,在XCode 9
上还会报崩溃。这是为什么呢?
这是因为我们在主线程中执行syncMain
方法,相当于把syncMain
任务放到了主线程的队列中。而同步执行会等待当前队列中的任务执行完毕,才会接着执行。那么当我们把任务1追加到主队列中,任务1就在等待主线程处理完syncMain
任务。而syncMain
任务需要等待任务1执行完毕,才能接着执行。形成了相互等待!
所以,现在的情况就是syncMain
任务和任务1都在等对方执行完毕。这样大家互相等待,所以就卡住了,所以我们的任务执行不了,而且---end
也没有打印。
要是如果不在主线程中调用,而在其他线程中调用会如何呢?
3.5.2 在其他线程中调用 同步执行 + 主队列
不会开启新线程,执行完一个任务,再执行下一个任务。
// 使用 NSThread 的 detachNewThreadSelector 方法会创建线程,并自动启动线程执行selector 任务
[NSThread detachNewThreadSelector:@selector(syncMain) toTarget:self withObject:nil];
输出结果
currentThread--->{number = 4, name = (null)}
--->begin
1--->{number = 1, name = main}
1--->{number = 1, name = main}
2--->{number = 1, name = main}
2--->{number = 1, name = main}
--->end
在其他线程中使用同步执行 + 主队列 可看到:
- 所有任务都是在主线程(非当前线程)中执行的,没有开启新的线程(所有放在主队列中的任务,都会放到主线程中执行)。
- 所有任务都在打印的
---begin
和---end
之间执行(同步任务需要等待队列的任务执行结束)。 - 任务是按顺序执行的(主队列是串行队列,每次只有一个任务被执行,任务一个接一个按顺序执行)。
为什么现在就不会卡住了呢?
因为syncMain
任务放到了其他线程里,而任务1、任务2都在追加到主队列中,这三个任务都会在主线程中执行。syncMain
任务在其他线程中执行到追加任务1到主队列中,因为主队列现在没有正在执行的任务,所以,会直接执行主队列的任务1,等任务1执行完毕,再接着执行任务2,所以这里不会卡住线程。
4.6 异步执行 + 主队列
只在主线程中执行任务,执行完一个任务,再执行下一个任务。
/**
* 异步执行 + 主队列
* 特点:只在主线程中执行任务,执行完一个任务,再执行下一个任务
*/
- (void)asyncMain {
// 打印当前线程
NSLog(@"currentThread--->%@",[NSThread currentThread]);
NSLog(@"--->begin");
dispatch_queue_t queue = dispatch_get_main_queue();
dispatch_async(queue, ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"1--->%@",[NSThread currentThread]);
}
});
dispatch_async(queue, ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
// 模拟耗时操作
[NSThread sleepForTimeInterval:2];
// 打印当前线程
NSLog(@"2--->%@",[NSThread currentThread]);
}
});
NSLog(@"--->end");
}
输出结果
currentThread--->{number = 1, name = main}
--->begin
--->end
1--->{number = 1, name = main}
1--->{number = 1, name = main}
2--->{number = 1, name = main}
2--->{number = 1, name = main}
在异步执行 + 主队列 可以看到:
- 所有任务都是在当前线程(主线程)中执行的,并没有开启新的线程(虽然异步执行具备开启线程的能力,但因为是主队列,所以所有任务都在主线程中)。
- 所有任务是在打印的
---begin
和---end
之后才开始执行的(异步执行不会做任何等待,可以继续执行任务)。 - 任务是按顺序执行的(因为主队列是串行队列,每次只有一个任务被执行,任务一个接一个按顺序执行)
5.线程死锁
- 主线程中使用 同步执行 + 主队列
- 串行异步嵌套同步
- NSOperation相互依赖
// 主线程中使用 同步执行 + 主队列*
- (void)deadlock1 {
NSLog(@"currentThread--->%@",[NSThread currentThread]);
dispatch_sync(dispatch_get_main_queue(), ^{
for (int i = 0; i < 2; ++i) {
// 打印当前线程
NSLog(@"1--->%@",[NSThread currentThread]);
}
});
NSLog(@"--->end");
}
// 串行异步嵌套同步(当前线程是主线程还是子线程都一样)
- (void)deadlock2 {
NSLog(@"currentThread--->%@",[NSThread currentThread]);
dispatch_async(self.serialQueue, ^{
NSLog(@"1--->%@",[NSThread currentThread]);
dispatch_sync(self.serialQueue, ^{
NSLog(@"2--->%@",[NSThread currentThread]);
});
NSLog(@"3--->%@",[NSThread currentThread]);
});
NSLog(@"--->end");
}
串行异步嵌套同步造成死锁的原因:因为串行队列任务是一个一个的执行完成,而同步任务也是要求任务上一个任务完成以后,才能继续进行下一个,这样就造成了相互等待。
Demo地址