目前多线程主要分为三类:
1 NSThread
2 NSOperation
3 GCD
前面两种网上资料很多,本文就苹果推荐使用的GCD理一理。
多线程相关概念
进程与线程的关系?
进程:app打开的时候会打开相应的进程,一般情况下,一个App会有一个或多个进程,但是iOS的App一般只有一个进程(后台播放,IM除外)。在iOS系统中,打开一个新的App会挂起其他App的进程。一个进程会包含一个或多个线程。
线程:一个线程同时只可以执行一个任务,多线程就可以同时执行多个任务。一个进程可以包含多个线程。
主线程和子线程(非主线程)到底有什么区别?
- 主线程:iOS程序中,主线程(又叫作UI线程)主要任务是处理UI事件,显示和刷新UI,(只有主线程有直接修改UI的能力)耗时的操作放在子线程(又叫作后台线程、异步线程)。
- 子线程:在iOS中开子线程去处理耗时的操作,可以有效提高程序的执行效率,提高资源利用率。
但是开启线程会占用一定的内存,(主线程的堆栈大小是1M,第二个线程开始都是512KB,并且该值不能通过编译器开关或线程API函数来更改)降低程序的性能。所以一般不要同时开很多线程。
注:查看当前线程信息用[NSThread currentThread],而不要用[NSOperationQueue currentQueue],因前者内容可以看到更全面的线程信息!
下面进入正题:
GCD
关键字:
(1). 异步与同步
异步执行:具备开新线程的能力,可以先绕过线程任务,回头再执行。
同步执行:不具备开新线程的能力,因此只能在当前线程中执行!任务执行必须按顺序执行(必须执行完当前任务才会继续走代码)。
(2). 并发队列与串行队列
并发队列:队列中的任务同时执行(Concurrent Dispatch Queue)
串行队列:队列中的任务按添加任务顺序执行(Serial Dispatch Queue)
注:这里说的任务就是GCD中block中的代码。
这里的关键字一般都是组合用,理解单个是没有意义的,组合后的效果:
以下两种同步执行的情况都是在主线程执行的:
dispatch_queue_t concurrentQueue = dispatch_queue_create("abcd", DISPATCH_QUEUE_CONCURRENT);//并发队列
//这里的abcd仅仅作为调试时用的标识符,打印线程属性时并不是name
dispatch_sync(concurrentQueue, ^{
[self loadImage:@10];
});
dispatch_sync(concurrentQueue, ^{
[self loadImage:@11];
});
dispatch_sync(concurrentQueue, ^{
[self loadImage:@12];
});
dispatch_sync(concurrentQueue, ^{
[self loadImage:@13];
});
打印log:
2017-06-28 10:38:54.797 多线程GCD[80605:13173361] 执行:10 线程信息:<NSThread: 0x600000073ec0>{number = 1, name = main}
2017-06-28 10:38:57.342 多线程GCD[80605:13173361] 执行:11 线程信息:<NSThread: 0x600000073ec0>{number = 1, name = main}
2017-06-28 10:38:59.681 多线程GCD[80605:13173361] 执行:12 线程信息:<NSThread: 0x600000073ec0>{number = 1, name = main}
2017-06-28 10:39:01.966 多线程GCD[80605:13173361] 执行:13 线程信息:<NSThread: 0x600000073ec0>{number = 1, name = main}
dispatch_queue_t serialQueue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);//串行队列
//这里的DISPATCH_QUEUE_SERIAL等价于NULL
dispatch_sync(serialQueue, ^{
[self loadImage:@5];
});
dispatch_sync(serialQueue, ^{
[self loadImage:@6];
});
dispatch_sync(serialQueue, ^{
[self loadImage:@7];
});
dispatch_sync(serialQueue, ^{
[self loadImage:@8];
});
打印log:
2017-06-28 10:45:30.928 多线程GCD[81007:13250389] 执行:5 线程信息:<NSThread: 0x600000065000>{number = 1, name = main}
2017-06-28 10:45:37.232 多线程GCD[81007:13250389] 执行:6 线程信息:<NSThread: 0x600000065000>{number = 1, name = main}
2017-06-28 10:45:39.713 多线程GCD[81007:13250389] 执行:7 线程信息:<NSThread: 0x600000065000>{number = 1, name = main}
2017-06-28 10:45:42.314 多线程GCD[81007:13250389] 执行:8 线程信息:<NSThread: 0x600000065000>{number = 1, name = main}
正确的打开方式:
dispatch_queue_t serialQueue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);//串行队列
dispatch_async(dispatch_queue_create("abcd", DISPATCH_QUEUE_SERIAL), ^{
dispatch_sync(serialQueue, ^{
[self loadImage:@5];
});
dispatch_sync(serialQueue, ^{
[self loadImage:@6];
});
dispatch_sync(serialQueue, ^{
[self loadImage:@7];
});
dispatch_sync(serialQueue, ^{
[self loadImage:@8];
});
});
打印log:
2017-06-28 10:47:15.677 多线程GCD[81128:13270066] 执行:5 线程信息:<NSThread: 0x60800007e000>{number = 3, name = (null)}
2017-06-28 10:47:18.103 多线程GCD[81128:13270066] 执行:6 线程信息:<NSThread: 0x60800007e000>{number = 3, name = (null)}
2017-06-28 10:47:20.470 多线程GCD[81128:13270066] 执行:7 线程信息:<NSThread: 0x60800007e000>{number = 3, name = (null)}
2017-06-28 10:47:22.774 多线程GCD[81128:13270066] 执行:8 线程信息:<NSThread: 0x60800007e000>{number = 3, name = (null)}
以上说的是同步的时候需要注意的,下面说一下异步的情况:
dispatch_queue_t serialQueue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);//串行队列
dispatch_async(serialQueue, ^{
[self loadImage:@0];
});
dispatch_async(serialQueue, ^{
[self loadImage:@1];
});
dispatch_async(serialQueue, ^{
[self loadImage:@2];
});
dispatch_async(serialQueue, ^{
[self loadImage:@3];
});
打印log:
2017-06-28 10:49:14.498 多线程GCD[81251:13288476] 执行:0 线程信息:<NSThread: 0x600000262680>{number = 3, name = (null)}
2017-06-28 10:49:17.125 多线程GCD[81251:13288476] 执行:1 线程信息:<NSThread: 0x600000262680>{number = 3, name = (null)}
2017-06-28 10:49:19.599 多线程GCD[81251:13288476] 执行:2 线程信息:<NSThread: 0x600000262680>{number = 3, name = (null)}
2017-06-28 10:49:21.934 多线程GCD[81251:13288476] 执行:3 线程信息:<NSThread: 0x600000262680>{number = 3, name = (null)}
dispatch_queue_t concurrentQueue = dispatch_queue_create("abcd", DISPATCH_QUEUE_CONCURRENT);//并发队列
dispatch_async(concurrentQueue, ^{
[self loadImage:@0];
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@1];
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@2];
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@3];
});
打印log:
2017-06-28 10:54:06.805 多线程GCD[81549:13342819] 执行:1 线程信息:<NSThread: 0x608000072f80>{number = 4, name = (null)}
2017-06-28 10:54:06.805 多线程GCD[81549:13341379] 执行:0 线程信息:<NSThread: 0x60800007b200>{number = 3, name = (null)}
2017-06-28 10:54:06.805 多线程GCD[81549:13342821] 执行:3 线程信息:<NSThread: 0x6080000743c0>{number = 6, name = (null)}
2017-06-28 10:54:06.805 多线程GCD[81549:13342820] 执行:2 线程信息:<NSThread: 0x60000026a400>{number = 5, name = (null)}
在串行队列异步执行过程中,会创建一个线程,按顺序执行当前线程中的任务。有阻塞!
在并发队列异步执行过程中,可能会创建多个线程,同时执行当前线程中的任务。没有阻塞!
dispatch_async(dispatch_queue_create("aaa", DISPATCH_QUEUE_SERIAL), ^{
[self loadImage:@0];
});
dispatch_async(dispatch_queue_create("bbb", DISPATCH_QUEUE_SERIAL), ^{
[self loadImage:@1];
});
dispatch_async(dispatch_queue_create("ccc", DISPATCH_QUEUE_SERIAL), ^{
[self loadImage:@2];
});
dispatch_async(dispatch_queue_create("ddd", DISPATCH_QUEUE_SERIAL), ^{
[self loadImage:@3];
});
dispatch_async(dispatch_queue_create("eee", DISPATCH_QUEUE_SERIAL), ^{
[self loadImage:@4];
});
打印log:
2017-06-28 11:05:10.966 多线程GCD[82282:13469275] 执行:2 线程信息:<NSThread: 0x608000076100>{number = 5, name = (null)}
2017-06-28 11:05:10.966 多线程GCD[82282:13469905] 执行:4 线程信息:<NSThread: 0x6080000738c0>{number = 6, name = (null)}
2017-06-28 11:05:10.966 多线程GCD[82282:13469278] 执行:3 线程信息:<NSThread: 0x608000075b40>{number = 7, name = (null)}
2017-06-28 11:05:10.966 多线程GCD[82282:13469331] 执行:1 线程信息:<NSThread: 0x600000076d00>{number = 4, name = (null)}
2017-06-28 11:05:10.966 多线程GCD[82282:13469276] 执行:0 线程信息:<NSThread: 0x60800006dcc0>{number = 3, name = (null)}
以上会创建5个串行队列线程,而不是1个串行队列线程,因为不是同一个线程,所以执行顺序是同时执行,互相没有影响(对于并发队列是同样的)。
正确使用方法应该是1中创建的方式,对于并发队列,计算机会根据性能和需要创建合理的线程数量。保证系统高性能和流畅性。
dispatch_async(dispatch_queue_create("a", DISPATCH_QUEUE_CONCURRENT), ^{
[self loadImage:@14];
});
dispatch_async(dispatch_queue_create("b", DISPATCH_QUEUE_CONCURRENT), ^{
[self loadImage:@15];
});
dispatch_async(dispatch_queue_create("c", DISPATCH_QUEUE_CONCURRENT), ^{
[self loadImage:@16];
});
dispatch_async(dispatch_queue_create("d", DISPATCH_QUEUE_CONCURRENT), ^{
[self loadImage:@17];
});
打印log:
2017-06-28 11:03:51.193 多线程GCD[82177:13453338] 执行:15 线程信息:<NSThread: 0x608000263040>{number = 4, name = (null)}
2017-06-28 11:03:51.193 多线程GCD[82177:13449499] 执行:14 线程信息:<NSThread: 0x608000261580>{number = 3, name = (null)}
2017-06-28 11:03:51.193 多线程GCD[82177:13453339] 执行:16 线程信息:<NSThread: 0x608000272f00>{number = 5, name = (null)}
2017-06-28 11:03:51.193 多线程GCD[82177:13453340] 执行:17 线程信息:<NSThread: 0x60000026e740>{number = 6, name = (null)}
Main Dispatch Queue/Global Dispatch Queue
实际上不用特意生成Dispatch Queue,系统也会为我们准备几个。那就是Main Dispatch Queue和Global Dispatch Queue。
Main Dispatch Queue就是主线程,因为主线程只有一个,所以Main Dispatch Queue是Serial Dispatch Queue。Main Dispatch Queue的处理在主线程的Runloop中执行。
相应的,Global Dispatch Queue是系统为我们准备的Concurrent Dispatch Queue。Global Dispatch Queue有四个优先级,应根据需求使用对应优先级。
优先级.png /**
high优先级的获取方法
*/
dispatch_queue_t globalHighQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
/**
default优先级的获取方法
*/
dispatch_queue_t globalDefaultQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
/**
low优先级的获取方法
*/
dispatch_queue_t globalLowQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_LOW, 0);
/**
background优先级的获取方法
*/
dispatch_queue_t globalBackgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
更改队列优先级:dispatch_set_target_queue(dispatch_object_t _Nonnull object, dispatch_queue_t _Nullable queue)
dispatch_queue_t serialQueue = dispatch_queue_create("aa", DISPATCH_QUEUE_SERIAL);//串行队列
dispatch_queue_t globalBackgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
dispatch_set_target_queue(serialQueue, globalBackgroundQueue);将serialQueue指定为globalBackgroundQueue用。
注:如果这里用函数dispatch_set_target_queue将多个Serial Dispatch Queue指定为同一个Serial Dispatch Queue,就会将原本并发的队列变更为串行队列。
关键字 Dispatch Group
/**
将原本在serialQueue中要执行的放在group里,后面可以加一个结束的回调(很多时候会有这种需求)
*/
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, serialQueue, ^{
//代码
});
dispatch_group_async(group, serialQueue, ^{
//代码
});
dispatch_group_async(group, serialQueue, ^{
//代码
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
NSLog(@"done");//执行完成后回调
});
关键字 dispatch_barrier_async 栅栏
dispatch_queue_t concurrentQueue = dispatch_queue_create("abcd", DISPATCH_QUEUE_CONCURRENT);//并行队列
dispatch_async(concurrentQueue, ^{
[self loadImage:@0];
//读取数据0
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@1];
//读取数据1
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@2];
//读取数据2
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@3];
//读取数据3
});
dispatch_barrier_async(concurrentQueue, ^{
[self loadImage:@4];
//异步栅栏写入数据4
});
dispatch_barrier_sync(concurrentQueue, ^{
[self loadImage:@4];
//同步栅栏写入数据4
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@5];
//读取数据5
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@6];
//读取数据6
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@7];
//读取数据7
});
dispatch_async(concurrentQueue, ^{
[self loadImage:@8];
//读取数据8
});
打印log:
2017-06-28 11:11:53.029 多线程GCD[82699:13543714] 执行:2 线程信息:<NSThread: 0x600000076d80>{number = 5, name = (null)}
2017-06-28 11:11:53.029 多线程GCD[82699:13543650] 执行:0 线程信息:<NSThread: 0x600000076d40>{number = 3, name = (null)}
2017-06-28 11:11:53.029 多线程GCD[82699:13543652] 执行:1 线程信息:<NSThread: 0x608000066940>{number = 4, name = (null)}
2017-06-28 11:11:53.029 多线程GCD[82699:13543715] 执行:3 线程信息:<NSThread: 0x608000071140>{number = 6, name = (null)}
2017-06-28 11:11:58.763 多线程GCD[82699:13544668] 异步栅栏执行:4 线程信息:<NSThread: 0x6080000710c0>{number = 8, name = (null)}
2017-06-28 11:12:01.195 多线程GCD[82699:13542941] 同步栅栏执行:4 线程信息:<NSThread: 0x600000066500>{number = 1, name = main}
2017-06-28 11:12:03.605 多线程GCD[82699:13543650] 执行:7 线程信息:<NSThread: 0x600000076d40>{number = 3, name = (null)}
2017-06-28 11:12:03.605 多线程GCD[82699:13544677] 执行:5 线程信息:<NSThread: 0x608000074bc0>{number = 9, name = (null)}
2017-06-28 11:12:03.605 多线程GCD[82699:13544668] 执行:6 线程信息:<NSThread: 0x6080000710c0>{number = 8, name = (null)}
2017-06-28 11:12:03.605 多线程GCD[82699:13543714] 执行:8 线程信息:<NSThread: 0x600000076d80>{number = 5, name = (null)}
在读取数据时,有时候会出现数据竞争,数据安全问题,比如:当前的写入没有结束,读取操作就开始处理,导致数据错乱。或者读取正在进行,开始写入操作,导致程序崩溃等问题。
苹果为我们提供了一个便捷的参数:dispatch_barrier_async(栅栏)。
作用:如上述代码中所表示,只有在1234操作完成时(无序),才会执行写入操作,只有当前写入操作结束后,才会继续向下执行。dispatch_barrier_sync也有同样的效果,但是如果不放入其他线程中的话,会在当前线程即主线程执行,会阻塞线程。
注意:dispatch_barrier_async中如果使用全局队列的话,就相当于要等待全局队列里的所有并发任务执行完后,才会执行dispatch_barrier_async中的任务,这样会受其他在全局队列里任务的影响,达不到我们想要的效果。
总结:
**
并发队列(Concurrent Dispatch Queue) 串行队列(Serial Dispatch Queue) :
负责执行顺序!
异步执行 (dispatch_async) 同步执行 (dispatch_sync):
负责选择线程执行!
**
网友评论