本地多个异步任务使用：队列组或者enter
网络多个异步任务使用：enter
网络多个异步任务互相有依赖关系需要同步执行：semaphore
线程安全锁：semaphore
参考https://www.jianshu.com/p/f536f9a17d90
多线程就是为了让子线程执行网络请求或者耗时任务，让主线程只负责处理UI，提高用户的UI交互体验。
线程同步技术：我们需要给数据添加互斥锁，如果给数据加了锁，就等于将这些异步的子线程变成同步的了。
OC在定义属性时有nonatomic和atomic两种选择
atomic：原子属性，为setter方法加锁（默认就是atomic），保证一次完整的访问是可以完成的，但是当并发量过大时，仍然会造成线程不安全的问题，所以一般都会直接使用nonatomic来提高性能。
nonatomic：非原子属性，不会为setter方法加锁
nonatomic和atomic对比
atomic：线程安全，需要消耗大量的资源
nonatomic：非线程安全，适合内存小的移动设备
建议：
所有属性都声明为nonatomic，尽量避免多线程抢夺同一块资源，将加锁、资源抢夺的业务逻辑交给服务器端处理，减小移动客户端的压力。
有些程序是一条直线，起点到终点；有些程序是一个圆，不断循环，直到将它切断
一个运行着的程序就是一个进程或者叫做一个任务，一个进程至少包含一个线程，线程就是程序的执行流。Mac和iOS中的程序启动，创建好一个进程的同时， 一个线程便开始运行，这个线程叫主线程。主线程在程序中的地位和其他线程不同，它是其他线程最终的父线程，且所有界面的显示 *** 作即AppKit或 UIKit的 *** 作必须在主线程进行。
系统中的每一个进程都有自己独立的虚拟内存空间，而同一个进程中的多个线程则共用进程的内存空间。每创建一个新的线程，都需要一些内存(如每个线程有自己的Stack空间)和消耗一定的CPU时间。另外当多个线程对同一个资源出现争夺的时候需要注意线程安全问题
多线程的实现原理：虽然在同一时刻，CPU只能处理1条线程，但是CPU可以快速地在多条线程之间调度（切换），造成了多线程并发执行的假象。
GCD 的使用步骤其实很简单，只有两步。
创建一个队列（串行队列或并发队列）
将任务追加到等待队列中，然后系统就会根据任务类型执行任务（同步执行或异步执行）
任务：就是执行 *** 作的意思，换句话说就是你在线程中执行的那段代码。在 GCD 中是放在 block 中的。执行任务有两种方式：同步执行（sync）和异步执行（async）。两者的主要区别是：是否等待队列的任务执行结束，以及是否具备开启新线程的能力。
dispatch_async：异步函数，这个函数会立即返回，不做任何等待，它所指定的block“非同步地”追加到指定的队列中。
dispatch_sync：同步函数，这个函数不会立即返回，它会一直等待追加到特定队列中的制定block完成工作后才返回，所以它的目的（也是效果）是阻塞当前线程（所以在主线程同步调用主队列就会互相阻塞，造成卡死，实际原因同步队列必须等之前进入同步队列的任务执行完成，但是在当前同步队列下的线程，同步函数调用同步队列执行任务时，会阻塞当前线程，也就是说，同步函数会阻塞当前线程，但是同步队列又要等当前队列执行完成才能继续执行，所以就卡死了）。
代码解释
-(void)test{
dispatch_queue_t que = dispatch_queue_create("que", DISPATCH_QUEUE_SERIAL);
dispatch_sync(que, ^{
NSLog(@"没有阻塞");
dispatch_sync(que, ^{
NSLog(@"会阻塞当前线程，并且要等当前线程执行完成才会往下执行，所以会卡死");
});
});
}
同步执行（sync）：
同步添加任务到指定的队列中，在添加的任务执行结束之前，会一直等待，直到队列里面的任务完成之后再继续执行。
只能在当前线程中执行任务，不具备开启新线程的能力。
异步添加任务到指定的队列中，它不会做任何等待，可以继续执行任务。
可以在新的线程中执行任务，具备开启新线程的能力。
Dispatch Queue是执行处理的等待队列，按照任务（block）追加到队列里的顺序，先进先出执行处理。
而等待队列有两种
Serial Dispatch Queue：串行队列，等待当前执行任务处理结束的队列。
Concurrent Dispatch Queue:并发队列，不等待当前执行任务处理结束的队列。
可以使用dispatch_queue_create来创建队列，需要传入两个参数，第一个参数表示队列的唯一标识符，用于 DEBUG，可为空，Dispatch Queue 的名称推荐使用应用程序 ID 这种逆序全程域名；第二个参数用来识别是串行队列还是并发队列。DISPATCH_QUEUE_SERIAL 表示串行队列，DISPATCH_QUEUE_ConCURRENT 表示并发队列。
// 串行队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_SERIAL);
// 并发队列的创建方法
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
串行队列
将任务追加到串行队列：
- (void)serialQueue
{
dispatch_queue_t queue = dispatch_queue_create("serial queue", NULL);
for (NSInteger index = 0; index < 6; index ++) {
dispatch_async(queue, ^{
NSLog(@"task index %ld in serial queue",index);
});
}
}
代码输出：
gcd_demo[33484:2481120] task index 0 in serial queue gcd_demo[33484:2481120] task index 1 in serial queue gcd_demo[33484:2481120] task index 2 in serial queue gcd_demo[33484:2481120] task index 3 in serial queue gcd_demo[33484:2481120] task index 4 in serial queue gcd_demo[33484:2481120] task index 5 in serial queue
通过dispatch_queue_create函数可以创建队列，第一个函数为队列的名称，第二个参数是NULL和DISPATCH_QUEUE_SERIAL时，返回的队列就是串行队列。
为了避免重复代码，我在这里使用了for循环，将任务追加到了queue中。
注意，这里的任务是按照顺序执行的。说明任务是以阻塞的形式执行的：必须等待上一个任务执行完成才能执行现在的任务。也就是说：一个Serial Dispatch Queue中同时只能执行一个追加处理（任务block），而且系统对于一个Serial Dispatch Queue只生成并使用一个线程。
但是，如果我们将6个任务分别追加到6个Serial Dispatch Queue中，那么系统就会同时处理这6个任务（因为会另开启6个子线程）：
- (void)multiSerialQueue
{
for (NSInteger index = 0; index < 10; index ++) {
//新建一个serial queue
dispatch_queue_t queue = dispatch_queue_create("different serial queue", NULL);
dispatch_async(queue, ^{
NSLog(@"serial queue index : %ld",index);
});
}
}
代码输出结果：
gcd_demo[33576:2485282] serial queue index : 1 gcd_demo[33576:2485264] serial queue index : 0 gcd_demo[33576:2485267] serial queue index : 2 gcd_demo[33576:2485265] serial queue index : 3 gcd_demo[33576:2485291] serial queue index : 4 gcd_demo[33576:2485265] serial queue index : 5
从输出结果可以看出来，这里的6个任务并不是按顺序执行的。
需要注意的是：一旦开发者新建了一个串行队列，系统一定会开启一个子线程，所以在使用串行队列的时候，一定只创建真正需要创建的串行队列，避免资源浪费。
并发队列将任务追加到并发队列：
- (void)concurrentQueue
{
dispatch_queue_t queue = dispatch_queue_create("concurrent queue", DISPATCH_QUEUE_CONCURRENT);
for (NSInteger index = 0; index < 6; index ++) {
dispatch_async(queue, ^{
NSLog(@"task index %ld in concurrent queue",index);
});
}
}
代码输出结果：
gcd_demo[33550:2484160] task index 1 in concurrent queue gcd_demo[33550:2484159] task index 0 in concurrent queue gcd_demo[33550:2484162] task index 2 in concurrent queue gcd_demo[33550:2484182] task index 3 in concurrent queue gcd_demo[33550:2484183] task index 4 in concurrent queue gcd_demo[33550:2484160] task index 5 in concurrent queue
可以看到，dispatch_queue_create函数的第二个参数是DISPATCH_QUEUE_CONCURRENT。
注意，这里追加到并发队列的6个任务并不是按照顺序执行的，符合上面并发队列的定义。
扩展知识：iOS和OSX基于Dispatch Queue中的处理数，CPU核数，以及CPU负荷等当前系统的状态来决定Concurrent Dispatch Queue中并发处理的任务数。
系统提供的队列 对于串行队列，GCD 提供了的一种特殊的串行队列：主队列（Main Dispatch Queue）。所有放在主队列中的任务，都会放到主线程中执行。
可使用dispatch_get_main_queue()获得主队列。
// 主队列的获取方法
dispatch_queue_t queue = dispatch_get_main_queue();对于并发队列，GCD 默认提供了全局并发队列（Global Dispatch Queue）。
可以使用dispatch_get_global_queue来获取。需要传入两个参数。第一个参数表示队列优先级，一般用DISPATCH_QUEUE_PRIORITY_DEFAULT。第二个参数暂时没用，用0即可。
// 全局并发队列的获取方法
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);任务的创建方法
GCD 提供了同步执行任务的创建方法dispatch_sync和异步执行任务创建方法dispatch_async。
// 同步执行任务创建方法
dispatch_sync(queue, ^{
// 这里放同步执行任务代码
});
// 异步执行任务创建方法
dispatch_async(queue, ^{
// 这里放异步执行任务代码
});
任务和队列的组合
1,同步执行 + 并发队列 :在当前线程中执行任务，不会开启新线程，执行完一个任务，再执行下一个任务。
2,异步执行 + 并发队列:可以开启多个线程，任务交替（同时）执行
3,同步执行 + 串行队列:不会开启新线程，在当前线程执行任务。任务是串行的，执行完一个任务，再执行下一个任务
4,异步执行 + 串行队列: 会开启新线程，但是因为是串行队列，所以只会开辟一个新线程，执行完一个任务，再执行下一个任务，同一个串行队列，在多个异步任务中使用，都只使用最先开辟的那一个线程。
5,同步执行 + 主队列:
5.1:在主线程中调用同步执行 + 主队列:互相等待卡住不可行(死锁)
5.2:在其他线程中调用同步执行 + 主队列:不会开启新线程，执行完一个任务，再执行下一个任务
6,异步执行 + 主队列:只在主线程中执行任务，执行完一个任务，再执行下一个任务
GCD 线程间的通信
在iOS开发过程中，我们一般在主线程里边进行UI刷新，例如：点击、滚动、拖拽等事件。我们通常把一些耗时的 *** 作放在其他线程，比如说图片下载、文件上传等耗时 *** 作。而当我们有时候在其他线程完成了耗时 *** 作时，需要回到主线程进行刷新UI或其他 *** 作，那么就用到了线程之间的通讯。
举个：并发加载图片，加载完成后在主线程刷新UI)：
//获取全局并发队列进行耗时 *** 作
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
//加载图片
NSData *dataFromURL = [NSData dataWithContentsOfURL:imageURL];
UIImage *imageFromData = [UIImage imageWithdata:dataFromURL];
dispatch_async(dispatch_get_main_queue(), ^{
//获取主队列，在图片加载完成后更新UIImageView
UIImageView *imageView = [[UIImageView alloc] initWithImage:imageFromData];
});
});
GCD 的其他方法
GCD 栅栏方法：dispatch_barrier_async
关于解决数据竞争的方法：读取处理是可以并发的，但是写入处理却是不允许并发执行的，比如数据库。
我们有时需要异步执行两组 *** 作，而且第一组 *** 作执行完之后，才能开始执行第二组 *** 作。这样我们就需要一个相当于栅栏一样的一个方法将两组异步执行的 *** 作组给分割起来，当然这里的 *** 作组里可以包含一个或多个任务。这就需要用到dispatch_barrier_async方法在两个 *** 作组间形成栅栏，只有将Barrier blocks提交到使用DISPATCH_QUEUE_CONCURRENT属性创建的并行queue时它才会表现的如同预期。
dispatch_barrier_async函数会等待前边追加到并发队列中的任务全部执行完毕之后，再将指定的任务追加到该异步队列中。然后在dispatch_barrier_async函数追加的任务执行完毕之后，异步队列才恢复为一般动作，接着追加任务到该异步队列并开始执行，不能使用全局并发队列。具体如下图所示：
这里有个需要注意也是官方文档上提到的一点，如果我们调用dispatch_barrier_async时将Barrier blocks提交到一个global queue，barrier blocks执行效果与dispatch_async()一致；只有将Barrier blocks提交到使用DISPATCH_QUEUE_CONCURRENT属性创建的并行queue时它才会表现的如同预期。
- (void)barrier {
dispatch_queue_t queue = dispatch_queue_create("net.bujige.testQueue", DISPATCH_QUEUE_CONCURRENT);
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]); // 打印当前线程
}
});
dispatch_barrier_async(queue, ^{
// 追加任务 barrier
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"barrier---%@",[NSThread currentThread]);// 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务3
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_async(queue, ^{
// 追加任务4
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"4---%@",[NSThread currentThread]); // 打印当前线程
}
});
}
GCD 延时执行方法：dispatch_after
在指定时间（例如3秒）之后执行某个任务。可以用 GCD 的dispatch_after函数来实现。
需要注意的是：dispatch_after函数并不是在指定时间之后才开始执行处理，而是在指定时间之后将任务追加到主队列中。严格来说，这个时间并不是绝对准确的，但想要大致延迟执行任务，dispatch_after函数是很有效的。
- (void)after {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"asyncMain---begin");
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
// 2.0秒后异步追加任务代码到主队列，并开始执行
NSLog(@"after---%@",[NSThread currentThread]); // 打印当前线程
});
}
GCD 一次性代码（只执行一次）：dispatch_once
我们在创建单例、或者有整个程序运行过程中只执行一次的代码时，我们就用到了 GCD 的 dispatch_once 函数。使用
dispatch_once 函数能保证某段代码在程序运行过程中只被执行1次，并且即使在多线程的环境下，dispatch_once也可以保证线程安全。
- (void)once {
static dispatch_once_t onceToken;
dispatch_once(&onceToken, ^{
// 只执行1次的代码(这里面默认是线程安全的)
});
}
GCD 快速迭代方法：dispatch_apply
dispatch_apply按照指定的次数将指定的任务（block）追加到指定的队列中，并等待全部队列执行结束。
如果是在串行队列中使用 dispatch_apply，那么就和 for 循环一样，按顺序同步执行。可这样就体现不出快速迭代的意义了。
我们可以利用并发队列进行异步执行。比如说遍历 0~5 这6个数字，for 循环的做法是每次取出一个元素，逐个遍历。dispatch_apply 可以 在多个线程中同时（异步）遍历多个数字。
还有一点，无论是在串行队列，还是异步队列中，dispatch_apply 都会等待全部任务执行完毕，再往下执行，这点就像是同步 *** 作，也像是队列组中的 dispatch_group_wait方法。
因为是在并发队列中异步执行任务，所以各个任务的执行时间长短不定，最后结束顺序也不定。但是apply—end一定在最后执行。这是因为dispatch_apply函数会等待全部任务执行完毕才会继续往下执行，从功能上来说和for循环是一样的，但是会多开辟线程，使用了更多的cpu资源，一般来说还是使用for循环。
- (void)apply {
dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
NSLog(@"apply---begin");
dispatch_apply(6, queue, ^(size_t index) {
NSLog(@"%zd---%@",index, [NSThread currentThread]);
});
NSLog(@"apply---end");
}
GCD 队列组：dispatch_group
有时候我们会有这样的需求：分别异步执行2个耗时任务，然后当2个耗时任务都执行完毕后再回到主线程执行任务。这时候我们可以用到 GCD 的队列组。
**本地耗时 *** 作可以将任务直接加到异步队列组dispatch_group_async执行。**网络耗时 *** 作，直接使用队列组可能会不同步。
网络异步队列需要使用GCD信号量才能实现同步
在实现本地耗时 *** 作时这两种方案的效果是一样的，但是当执行网络异步 *** 作时需要用dispatch_group_enter、dispatch_group_leave 组合 来实现，否则可能不能实现同步。参考文章：https://www.jianshu.com/p/3622f8b251e1
监听 group 中任务的完成状态，当所有的任务都执行完成后，追加任务到 group 中，并执行任务。不会阻塞当前线程（通常来说是主线程）
- (void)groupNotify {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_notify(group, dispatch_get_main_queue(), ^{
// 等前面的异步任务1、任务2都执行完毕后，回到主线程执行下边任务
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"3---%@",[NSThread currentThread]); // 打印当前线程
}
NSLog(@"group---end");
});
}
dispatch_group_wait
暂停当前线程（阻塞当前线程,一般是主线程），等待指定的 group 中的任务执行完成后，才会往下继续执行。超时后继续仍然会继续执行任务。但是block在到达超时时间后或者任务执行完后都会被执行，
- (void)groupWait {
NSLog(@"currentThread---%@",[NSThread currentThread]); // 打印当前线程
NSLog(@"group---begin");
dispatch_group_t group = dispatch_group_create();
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务1
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:2]; // 模拟耗时操作
NSLog(@"1---%@",[NSThread currentThread]); // 打印当前线程
}
});
dispatch_group_async(group, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
// 追加任务2
for (int i = 0; i < 2; ++i) {
[NSThread sleepForTimeInterval:5]; // 模拟耗时操作
NSLog(@"2---%@",[NSThread currentThread]); // 打印当前线程
}
});
// 等待上面的任务全部完成后，会往下继续执行（会阻塞当前线程）
long result = dispatch_group_wait(group, 2);
NSLog(@"group---end");
if (result == 0) {
NSLog(@"group内部的任务全部结束");
}else{
NSLog(@"虽然过了超时时间，group还有任务没有完成");
}
}
GCD 信号量：dispatch_semaphore
Dispatch Semaphore 在实际开发中主要用于：
保持线程同步，将异步执行任务转换为同步执行任务,解决异步任务数据崩溃等问题 保证线程安全，为线程加锁
信号量的使用前提是：想清楚你需要处理哪个线程等待（阻塞），又要哪个线程继续执行，然后使用信号量
GCD 中的信号量是指 Dispatch Semaphore，是持有计数的信号。
Dispatch Semaphore 提供了三个函数。
dispatch_semaphore_create：创建一个Semaphore并初始化信号的总量（同时有几个线程可以执行，一般是1） dispatch_semaphore_wait：可以使总信号量减1，当信号总量小于0时就会一直等待（阻塞所在线程），否则就可以正常执行，这个放在要执行的代码的前面。 dispatch_semaphore_signal：发送一个信号，让信号总量加1，代码执行完成之后使用，使其他线程可以继续执行Dispatch Semaphore 线程同步
我们在开发中，会遇到这样的需求：异步执行耗时任务，并使用异步执行的结果是其他异步的前置条件,比如异步网络请求的数据存在依赖关系时。换句话说，相当于，将将异步执行任务转换为同步执行任务。比如说：AFNetworking 中 AFURLSessionManager.m 里面的 tasksForKeyPath: 方法。通过引入信号量的方式，等待异步执行任务结果，获取到 tasks，然后再返回该 tasks。
- (NSArray *)tasksForKeyPath:(NSString *)keyPath {
__block NSArray *tasks = nil;
dispatch_semaphore_t semaphore = dispatch_semaphore_create(0);
[self.session getTasksWithCompletionHandler:^(NSArray *dataTasks, NSArray *uploadTasks, NSArray *downloadTasks) {
if ([keyPath isEqualToString:NSStringFromSelector(@selector(dataTasks))]) {
tasks = dataTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(uploadTasks))]) {
tasks = uploadTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(downloadTasks))]) {
tasks = downloadTasks;
} else if ([keyPath isEqualToString:NSStringFromSelector(@selector(tasks))]) {
tasks = [@[dataTasks, uploadTasks, downloadTasks] valueForKeyPath:@"@unionOfArrays.self"];
}
dispatch_semaphore_signal(semaphore);
}];
dispatch_semaphore_wait(semaphore, DISPATCH_TIME_FOREVER);
return tasks;
}
分析：semaphore—end 是在执行完 number = 100; 之后才打印的。而且输出结果 number 为 100。
这是因为异步执行不会做任何等待，可以继续执行任务。异步执行将任务1追加到队列之后，不做等待，接着执行dispatch_semaphore_wait方法。此时 semaphore == 0，当前线程进入等待状态。然后，异步任务1开始执行。任务1执行到dispatch_semaphore_signal之后，总信号量，此时 semaphore == 1，dispatch_semaphore_wait方法使总信号量减1，正在被阻塞的线程（主线程）恢复继续执行。最后打印semaphore—end,number = 100。这样就实现了线程同步，将异步执行任务转换为同步执行任务。
线程安全：如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时访问同一个数据或者代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的（多线程运行的结果和预期一致）。
若每个线程中对全局变量、静态变量只有读 *** 作，而无写 *** 作，一般来说，这个全局变量是线程安全的；若有多个线程同时执行写 *** 作（更改变量），一般都需要考虑线程同步，否则的话就可能影响线程安全。
线程同步：可理解为线程 A 和 线程 B 一块配合，A 执行到一定程度时要依靠线程 B 的某个结果，于是停下来，示意 B 运行；B 依言执行，再将结果给 A；A 再继续 *** 作。
线程安全（使用 semaphore 加锁）确保只有一个线程在访问公共数据。
UIkit的类只能在主线程执行，所以绝对是安全的，属性使用nonatomic.
1，synchronized加锁，属于互斥锁，当有线程执行锁住的代码的时候，其他线程会进入休眠，需要唤醒后才能继续执行，性能较低。
-(void)test3{
dispatch_async(dispatch_get_global_queue(0, 0), ^{
@synchronized (self) {//加锁保证block中执行完成才会执行其他的
NSLog(@"1开始");
sleep(2);
NSLog(@"1结束");
}
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
@synchronized (self) {
NSLog(@"2开始");
sleep(2);
NSLog(@"2结束");
}
});
}
2,信号量semaphore加锁，属于自旋锁，当有线程执行锁住的代码的时候，其他线程会进入死循环的等待，当解锁后会立即执行，性能较高。
-(void)test3{
dispatch_semaphore_t semalook = dispatch_semaphore_create(1);
dispatch_async(dispatch_get_global_queue(0, 0), ^{
dispatch_semaphore_wait(semalook, DISPATCH_TIME_FOREVER);
NSLog(@"1开始");
sleep(2);
NSLog(@"1结束");
dispatch_semaphore_signal(semalook);
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
dispatch_semaphore_wait(semalook, DISPATCH_TIME_FOREVER);
NSLog(@"2开始");
sleep(2);
NSLog(@"2结束");
dispatch_semaphore_signal(semalook);
});
}
3，NSLock
-(void)test3{
NSLock *lock = [[NSLock alloc]init];
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[lock lock];
NSLog(@"1开始");
sleep(2);
NSLog(@"1结束");
[lock unlock];
});
dispatch_async(dispatch_get_global_queue(0, 0), ^{
[lock lock];
NSLog(@"2开始");
sleep(2);
NSLog(@"2结束");
[lock unlock];
});
}
dispatch_set_target_queue
这个函数有两个作用：
1,改变队列的优先级。
2,防止多个串行队列的并发执行。
dispatch_queue_create方法生成的串行队列合并发队列的优先级都是与默认优先级的Globle Dispatch Queue一致。
如果想要变更某个队列的优先级，需要使用dispatch_set_target_queue函数。
举个：创建一个在后台执行动作处理的Serial Dispatch Queue
//需求：生成一个后台的串行队列
- (void)changePriority
{
dispatch_queue_t queue = dispatch_queue_create("queue", NULL);
dispatch_queue_t bgQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0);
//第一个参数：需要改变优先级的队列；
//第二个参数：目标队列
dispatch_set_target_queue(queue, bgQueue);
}
防止多个串行队列的并发执行
如果是将任务追加到5个串行队列中，那么这些任务就会并发执行。因为每个串行队列都会创建一个线程，这些线程会并发执行。
如果将多个串行的queue使用dispatch_set_target_queue指定到了同一目标，那么这多个串行queue在目标queue上就是同步执行的，不再是并行执行。
将串行队列加入指定优先级队列，会按照加入优先级队列的顺序依次执行串行队列。
+(void)testTargetQueue {
dispatch_queue_t targetQueue = dispatch_queue_create("test.target.queue", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue1 = dispatch_queue_create("test.1", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue2 = dispatch_queue_create("test.2", DISPATCH_QUEUE_SERIAL);
dispatch_queue_t queue3 = dispatch_queue_create("test.3", DISPATCH_QUEUE_SERIAL);
dispatch_set_target_queue(queue1, targetQueue);
dispatch_set_target_queue(queue2, targetQueue);
dispatch_set_target_queue(queue3, targetQueue);
dispatch_async(queue1, ^{
NSLog(@"1 in");
[NSThread sleepForTimeInterval:3.f];
NSLog(@"1 out");
});
dispatch_async(queue2, ^{
NSLog(@"2 in");
[NSThread sleepForTimeInterval:2.f];
NSLog(@"2 out");
});
dispatch_async(queue3, ^{
NSLog(@"3 in");
[NSThread sleepForTimeInterval:1.f];
NSLog(@"3 out");
});
}
dispatch_suspend/dispatch_resume
dispatch_suspend并不会立即暂停正在运行的block，而是在当前block执行完成后，暂停后续的block执行。
// 挂起指定队列
dispatch_suspend(queue);
// 恢复指定队列
dispatchp_resume(queue);
dispatch_queue_t queue = dispatch_queue_create("com.test.gcd", DISPATCH_QUEUE_SERIAL);
//提交第一个block，延时5秒打印。
dispatch_async(queue, ^{
sleep(5);
NSLog(@"After 5 seconds...");
});
//提交第二个block，也是延时5秒打印
dispatch_async(queue, ^{
sleep(5);
NSLog(@"After 5 seconds again...");
});
//延时一秒
NSLog(@"sleep 1 second...");
sleep(1);
//挂起队列
NSLog(@"suspend...");
dispatch_suspend(queue);
//延时10秒
NSLog(@"sleep 10 second...");
sleep(10);
//恢复队列
NSLog(@"resume...");
dispatch_resume(queue);
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）