iOS 多线程应用的方方面面

作者: 波儿菜 | 来源:发表于2017-11-30 17:09 被阅读244次

前言

讲解多线程的博文很多，但大部分是标榜着“底层原理”、“深入探究”标签的水文。本文主要是探究的角度讲解iOS多线程应用层面的东西，基本不会涉及到底层，但是可以以此窥探多线程的原理。

一、多线程概述

进程与线程：线程是进程内假想的持有CPU使用权的执行单位。一个程序启动便有一个进程，一个进程可以有多个线程，但只有一个主线程。
父线程与子线程：创建线程时，创建方的线程为父线程，被创建方的线程为子线程。父线程可以等到子线程执行完毕后与其会和；也可以切断它们的关系让它们分离（比如NSThread）。
共享变量：多个线程都能访问的变量称为共享变量，因为地址空间是共享的，所以理论上所有的内存区域都是共享变量。如果不同线程同时访问同一个变量，这个变量就是不安全的，我们需要通过一些骚操作来实现线程间互斥（比如后面会讲的各种锁）
并发与并行：并行一定并发，并发不一定并行。在单核设备上，CPU通过频繁的切换上下文来运行不同的线程，速度足够快以至于我们看起来它是‘并行’处理的，然而我们只能说这种情况是并发而非并行。例如：你和两个人一起百米赛跑，你一直在不停的切换跑道，而其他两人就在自己的跑道上，最终，你们三人同时到达了终点。我们把跑道看做任务，那么，其他两人就是并行执行任务的，而你只能的说是并发执行任务（嗯，这个例子还行）。
多线程底层：多线程的底层实现机制是基于Mach的，Mach是第一个以多线程处理任务的系统，但是Mach级别的线程是相互独立的，线程之间不能通讯。

二、GCD

GCD（Grand Central Dispatch）是iOS4引入的强大的线程处理技术，它是基于XNU内核开发的，性能极为优越。

GCD是最受欢迎的多线程处理框架，多数情况我们都可以使用它来进行并行编程，而且基本不用关心线程的管理问题。当然，也有很多情况使用C的API不是那么方便和易于理解（或者说不符合面向对象思想），这时候就是NSOperation发挥作用的时候了（后一篇会讲）。

学习编程不是说那谁谁会多少API，这本身没有什么意义。学习GCD我将重点分析它是如何发生的，本质的原理，而不是故作玄虚的使用GCD所谓的“高级用法”和谈论所谓的“底层实现”，最终目的只是为了让各位真正的理解GCD的精髓🤝。

（一）队列&任务

任务：任务就是一段代码，我们可以直观的想象成GCD里面的block。
- 同步任务（sync）：同步任务会在当前线程执行，我们通常在编写UI相关的代码的时候，都是在主线程同步执行的。
- 异步任务（async）：异步任务就是会在当前线程之外的线程执行，当然是不是每一个异步任务都需要开辟新线程由GCD判断。
队列：GCD提供队列（dispatch queue）来管理任务，队列本身是线程安全的，通过FIFO（first in first out）原则来实现对任务的管理，即先加入的任务的先取出来执行。
- 串行队列：任务将会遵循FIFO原则拿出来依次执行，同一时刻只会有一个任务在执行（就像400米接力赛，只看一个队伍，一个接一个依次跑）。
- 并行队列：任务同样会遵循FIFO原则拿出来依次执行（这里值得注意），同一时刻有多个任务同时执行（就像100米赛跑，大家同时跑），它们可以理论上说是并行的。

1、创建串行队列

//@param1  队列的标志，一般以倒置的域名+队列的名字命名
//@param2  队列的类型的标志

//创建串行队列
dispatch_queue_t serialQueue = dispatch_queue_create("com.myProject.queue1", DISPATCH_QUEUE_SERIAL);

//获取主队列
dispatch_queue_t mainQueue = dispatch_get_main_queue();

主队列是由系统默认创建的，它管理着我们的主线程和相关的任务（当然可能不止一个主线程），主队列是串行队列。

2、创建并行队列

//创建并行队列
dispatch_queue_t concurrentQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_CONCURRENT);

//获取全局队列
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

全局队列同样是由系统默认创建的，我们的很多操作都可以利用它来完成，全局队列是并行队列。

3、创建同步任务

dispatch_sync(anyQueue, ^{
    //任务代码
});

anyQueue就是上面说到的队列

4、创建异步任务

dispatch_async(anyQueue, ^{
    //任务代码
});

anyQueue就是上面说到的队列

（二）任务和队列的组合

为了让大家更直观的感受到队列、任务、线程是如何工作的，这里直接放上它们的各种组合用法（分析得比较细，所以篇幅较长，见谅）。

1、串行队列+同步任务

dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_queue_t serialQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_SERIAL);

NSLog(@"主队列：%@ \n创建的串行队列：%@", mainQueue, serialQueue);
NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_sync(serialQueue, ^{
    NSLog(@"任务1执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

dispatch_sync(serialQueue, ^{
    NSLog(@"任务2执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

NSLog(@"主线程结束");

我这里写上了主队列只是为了测试用，使用[NSThread sleepForTimeInterval:4];是为了延长任务的执行时间，运行这段代码打印如下：

主队列：<OS_dispatch_queue_main: com.apple.main-thread> 
创建的串行队列：<OS_dispatch_queue: com.myProject.queue2>
主线程：<NSThread: 0x60400006f9c0>{number = 1, name = main}
主线程开始
任务1执行 <NSThread: 0x60400006f9c0>{number = 1, name = main}
任务2执行 <NSThread: 0x60400006f9c0>{number = 1, name = main}
主线程结束

打印的结果就很值得研究一下了。
第一点：我们创建了一个串行队列，它确实和我们的主队列不是同一块内存（看打印信息），然而我们在创建的队列中执行任务，同样是用的是主线程（number = 1），这就是同步执行任务。当前线程是主线程，所以就和主线程同步执行（这句话值得多读几遍，思考：如果当前线程是其他线程呢？马上会讲）。
第二点：任务1执行完毕过后任务2才开始执行，任务2执行完毕主线程结束才打印出来，这符合串行队列对任务的处理规则，依次执行。

重点一：更改dispatch_sync执行线程

在上面代码中，两个dispatch_sync函数都是在主线程执行的，所以dispatch_sync中的任务是在主线程执行，这就是同步的真正意义。如果我们让dispatch_sync在另外的线程执行，看看结果是否是我们预料的（dispatch_sync中的任务会在它执行的线程执行）：

dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_queue_t serialQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_SERIAL);

NSLog(@"主队列：%@ \n创建的串行队列：%@", mainQueue, serialQueue);
NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

[NSThread detachNewThreadWithBlock:^{
   
    NSLog(@"新开辟的线程：%@", [NSThread currentThread]);
    
    dispatch_sync(serialQueue, ^{
        NSLog(@"任务1执行 %@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:4];
    });
    
    dispatch_sync(serialQueue, ^{
        NSLog(@"任务2执行 %@", [NSThread currentThread]);
        [NSThread sleepForTimeInterval:4];
    });
    
}];

NSLog(@"主线程结束");

打印如下：

主队列：<OS_dispatch_queue_main: com.apple.main-thread> 
创建的串行队列：<OS_dispatch_queue: com.myProject.queue2>
主线程：<NSThread: 0x604000063300>{number = 1, name = main}
主线程开始
主线程结束
新开辟的线程：<NSThread: 0x60400026bb40>{number = 3, name = (null)}
任务1执行 <NSThread: 0x60400026bb40>{number = 3, name = (null)}
任务2执行 <NSThread: 0x60400026bb40>{number = 3, name = (null)}

看到了么，dispatch_sync函数在新开辟的线程（number = 3）中执行，任务1和任务2也在这个线程中执行，而主线程结束在执行两个任务之前打印，所以它同步的线程是这个新线程，而不再是我们的主线程了。理解这点非常重要。

重点二：主线程+同步任务

我们将任务1的队列改为主队列，代码如下：

dispatch_sync(dispatch_get_main_queue(), ^{
    NSLog(@"任务1执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

运行代码过后，直接崩溃，这里形成了死锁，很多文章在这个地方往往含糊其辞，这里需要重点说明一下（当然这是我的理解，可能会有错误，欢迎指出）。

解析：首先我们要明白，dispatch_sync函数是在主队列执行的，相当于主队列的一个任务，dispatch_sync任务执行完毕的条件是后边的block代码块执行完毕（而dispatch_async是立即返回的），所以，此刻主队列在等待dispatch_sync函数执行完毕；与此同时，我们将任务1也加入到了主队列中，任务1理所当然的会等待上一个任务执行完毕才会执行（FIFO原则）。
而不巧的是，上一个任务就是dispatch_sync函数，dispatch_sync函数执行完毕需要任务1执行完毕。这就异常尴尬了，所以就造成了死锁，如果没看明白多看几遍，理解了这个地方死锁的原因你将触摸到GCD的精髓。

这也就是之前代码顺利运行的原因，dispatch_sync函数加入到了mainQueue队列中，任务1加入到了serialQueue队列中，就不存在相互等待从而造成死锁了。

2、串行队列+异步任务

同样是之前的代码，把dispatch_sync改为dispatch_async就OK了，我还是贴上全部代码吧，照顾伸手党哈哈

dispatch_queue_t mainQueue = dispatch_get_main_queue();
dispatch_queue_t serialQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_SERIAL);

NSLog(@"主队列：%@ \n创建的串行队列：%@", mainQueue, serialQueue);
NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_async(serialQueue, ^{
    NSLog(@"任务1执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

dispatch_async(serialQueue, ^{
    NSLog(@"任务2执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

NSLog(@"主线程结束");

主队列：<OS_dispatch_queue_main: com.apple.main-thread> 
创建的串行队列：<OS_dispatch_queue: com.myProject.queue2>
主线程：<NSThread: 0x60000006aa80>{number = 1, name = main}
主线程开始
主线程结束
任务1执行 <NSThread: 0x60000007ab00>{number = 3, name = (null)}
任务2执行 <NSThread: 0x60000007ab00>{number = 3, name = (null)}

看到了么，由于任务是异步的，执行了dispatch_async函数过后主线程立即返回打印了主线程结束，我们的两个任务没有对主线程没有造成阻塞。GCD自动为我们开辟了一个线程，而任务1和任务2加入的队列仍然是串行队列，所以任务2是在任务1结束之后执行的。(没有加太多打印日志，最好上机试试)

重点：若这里把`serialQueue`换成`主队列 mainQueue`会发生什么呢？

这里就不上代码了。

队列换成主队列过后，任务1和任务2执行的线程就变成了主线程，并且任务1和任务2获取到了主线程的使用权并执行。在主队列异步执行任务，这是我们用来获取主线程且不会死锁的常用做法，也是我们开发中用来刷新UI经常会使用到的方法，如下：

dispatch_async(dispatch_get_main_queue(), ^{
    //更新UI
});

记住：针对于串行队列，dispatch_async函数在哪个线程执行并不影响dispatch_async内部的代码块在哪个线程执行（这和dispatch_sync函数不同），这取决于任务所在的串行队列，串行队列会根据任务进入的顺序安排同一个线程依次执行。所以，在想要回到主线程的时候，在任意线程调用上述代码就可以轻松的获取到主线程。

3、并行队列+同步任务

说明一下，使用系统提供的全局队列和自己创建的并行队列没有什么本质的区别，在日常开发中，少量的任务建议使用全局队列，如果任务处理量大，那就自己创建一个并且管理它。

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_sync(globalQueue, ^{
    NSLog(@"任务1执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_sync(globalQueue, ^{
    NSLog(@"任务2执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

NSLog(@"主线程结束");

主线程：<NSThread: 0x60400007a1c0>{number = 1, name = main}
主线程开始
任务1执行 <NSThread: 0x60400007a1c0>{number = 1, name = main}
任务2执行 <NSThread: 0x60400007a1c0>{number = 1, name = main}
主线程结束

细心的朋友可能发现了，这和串行队列+同步任务执行逻辑一模一样。

是的，只要dispatch_sync在主线程执行了，就注定了里面的任务会在主线程执行，而这里虽然队列是并行队列，但它也没办法，它也不允许找第二个线程来并行执行任务2了，所以串行队列+同步任务和并行队列+同步任务并没有表象上的区别。

4、并行队列+异步任务

需要上机测试才能很好理解

dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_async(globalQueue, ^{
    NSLog(@"任务1执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_async(globalQueue, ^{
    NSLog(@"任务2执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_async(globalQueue, ^{
    NSLog(@"任务3执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_async(globalQueue, ^{
    NSLog(@"任务4执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

NSLog(@"主线程结束");

主线程：<NSThread: 0x60000006ec00>{number = 1, name = main}
主线程开始
主线程结束
任务1执行 <NSThread: 0x600000273000>{number = 3, name = (null)}
任务3执行 <NSThread: 0x6040002775c0>{number = 4, name = (null)}
任务4执行 <NSThread: 0x600000273040>{number = 5, name = (null)}
任务2执行 <NSThread: 0x600000273080>{number = 6, name = (null)}

这里需要说明的是，四个不同的线程同时运作，任务1到任务4几乎都是同时执行的，可以不严密的说是并发且并行，这就是并行队列做的事情。而且主线程结束是在任务执行之前打印的，说明主线程没有受这几个任务的影响，这也体现了异步任务的功能。

注意：并不是并行队列同时执行几个任务就会开辟几个线程，我们知道并行队列也是FIFO的取出任务来执行，所以有一种可能是：后面某个任务还没取出的时候，前面某个任务已经结束了，这时候并行队列就会复用前面那个已经结束任务所在的线程了。

这种组合在各大开源框架和日常开发中都经常会用到，后台执行耗时操作的特性极大的提高了人机交互的流畅度。

（三）GCD一些其他用法

1、dispatch_barrier 栅栏

dispatch_barrier使用的场景之一就是在并行队列中强行插入一个栅栏，以达到我们为并行任务的分组控制（举个例子，有多个并行的任务，我们需要让其中几个任务执行结束过后，再通过一些计算得到后面几个任务需要的东西，这就需要用到栅栏了）。

dispatch_queue_t concurrentQueue = dispatch_queue_create("com.myProject.queue2", DISPATCH_QUEUE_CONCURRENT);
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_async(concurrentQueue, ^{
    NSLog(@"任务1执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_async(concurrentQueue, ^{
    NSLog(@"任务2执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_barrier_sync(concurrentQueue, ^{
    NSLog(@"任务barrier执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_async(concurrentQueue, ^{
    NSLog(@"任务3执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_async(concurrentQueue, ^{
    NSLog(@"任务4执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

NSLog(@"主线程结束");

主线程：<NSThread: 0x604000064640>{number = 1, name = main}
主线程开始
任务2执行 <NSThread: 0x6000002792c0>{number = 3, name = (null)}
任务1执行 <NSThread: 0x60400007f080>{number = 4, name = (null)}
任务barrier执行 <NSThread: 0x604000064640>{number = 1, name = main}
主线程结束
任务4执行 <NSThread: 0x6000002792c0>{number = 3, name = (null)}
任务3执行 <NSThread: 0x60400007f080>{number = 4, name = (null)}

说明一下：

主线程开始执行
任务都加入自定义的并行队列，排在barrier前面的任务1任务2开始并行执行
等到任务1和任务2都执行完毕，开始执行barrier里面任务
等到barrier里任务执行完毕，主线程结束，并且任务3任务4开始并行执行

注意一：我这上面用的是dispatch_barrier_sync，所以barrier里面的任务会在主线程执行，而且会占用主线程导致主线程结束在barrier任务执行结束之后才打印。
如果我们将dispatch_barrier_sync换成dispatch_barrier_async，执行barrier任务的线程就由并行队列自行安排，不会影响主线程，主线程结束将在并行任务开始执行之前打印。(可自行试试)

注意二：dispatch_barrier_sync和dispatch_barrier_async都会阻塞传入的队列，并且这个传入的队列不能是系统提供的主队列和全局队列，否则就失去了使用它们的意义，就和使用dispatch_async和dispatch_sync一样的效果了。

关于栅栏更多的细节这里就不多说了，可以去看看苹果官方文档，了解了解就行了，用得也不多。

2、dispatch_after 延时执行

延时函数，大家不陌生，需要注意的是，我们dispatch_after函数一旦返回就无法取消，所以有些时候我们还是喜欢用NSObject的实例方法performSelector: withObject: afterDelay:，因为可以用cancelPreviousPerformRequestsWithTarget:等方法取消这个还没到时间的延时操作；还有一点是，dispatch_after最好在主队列执行。

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
        NSLog(@"延时了两秒");
});

3、dispatch_once 实现单例模式

我见过有人使用下面这种方式实现单例模式：

static AnyObject obj = nil;
if (!obj) {
    //初始化
}

这种方式明显是线程不安全的，正确高效的方法如下：

static AnyObject obj = nil;
static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
     //初始化
});

该dispatch_once是线程安全的，并且官方称其性能很好，所以如果大家有兴趣可以测试下性能问题。

4、dispatch_apply 快速迭代

用法很简单，for循环和枚举遍历都是挨着把元素取出来，dispatch_apply可以快速同时遍历，用法简单：

dispatch_apply(6, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^(size_t i) {
  //执行任务
});

5、调度组：dispatch_group

一个金典的使用场景就是获取到所有任务完成的回调：

//创建调度组
dispatch_group_t group = dispatch_group_create();

//获取全局队列
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_group_async(group, globalQueue, ^{
    NSLog(@"任务1执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});
dispatch_group_async(group, globalQueue, ^{
    NSLog(@"任务2执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
});

dispatch_group_notify(group, globalQueue, ^{
    NSLog(@"任务全部完成");
});

NSLog(@"主线程结束");

主线程：<NSThread: 0x600000066b00>{number = 1, name = main}
主线程开始
主线程结束
任务1执行 <NSThread: 0x60000027c0c0>{number = 3, name = (null)}
任务2执行 <NSThread: 0x604000261c40>{number = 4, name = (null)}
任务全部完成

当然，你可以将队列换做主队列或其他队列，调度组同样能监听到任务全部完成的回调，我们还可以这样写：

//创建调度组
dispatch_group_t group = dispatch_group_create();

//获取全局队列
dispatch_queue_t globalQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

NSLog(@"主线程：%@", [NSThread currentThread]);

NSLog(@"主线程开始");

dispatch_group_enter(group);
dispatch_async(globalQueue, ^{
    NSLog(@"任务1执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
    dispatch_group_leave(group);
});

dispatch_group_enter(group);
dispatch_async(globalQueue, ^{
    NSLog(@"任务2执行 %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:4];
    dispatch_group_leave(group);
});

dispatch_group_notify(group, globalQueue, ^{
    NSLog(@"任务全部完成");
});

//dispatch_group_wait(group, DISPATCH_TIME_FOREVER);

NSLog(@"主线程结束");

两种方式都能达到同样的效果，需要注意的是dispatch_group_enter和dispatch_group_leave需要一一对应。注意到上面我注释了一句代码么dispatch_group_wait(group, DISPATCH_TIME_FOREVER);，我们将它的注释取消，会发现主线程被阻塞了，当我们的两个任务都执行完毕过后才会打印主线程结束。

三、NSOperation

NSOperation是基于GCD的面向对象封装，在各大开源库里面我们常常看到它的身影。它的使用很简单易懂，基本上你点进Api就会用了，本文就最常用的功能进行讲解，更多的多线程原理还是看本系列文章的GCD部分。

（一）NSBlockOperation和NSInvocationOperation

这两个类都是NSOperation的子类，它们的区别可能就是一个是用block回调，一个是用NSInvocation 回调，我们通常直接使用的也是这两个类，下面代码示意如何创建任务：

NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{}];

NSInvocationOperation *invocationOperation = [[NSInvocationOperation alloc] initWithTarget:self selector:@selector(respondsToOperation:) object:nil];

都不用多说了，这就是两个任务，非常简单，当然，它还有一系列的方法表示状态：executing、finished、cancelled，以及开启和取消：start、cancel，和NSThread一样有main方法可重写。

（二）NSOperationQueue 队列

和GCD一样，NSOperation保留了队列的概念，但是没有具体的并行和串行的概念了，但是我们可以实现它。

先来看这样一段代码：

NSLog(@"主线程开始");

NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务0 %@", [NSThread currentThread]);
}];
for (int i = 1; i < 5; i++) {
    [blockOperation addExecutionBlock:^{
        NSLog(@"任务%d: %@", i, [NSThread currentThread]);
        [NSThread sleepForTimeInterval:3];
    }];
}
[blockOperation start];

NSLog(@"主线程结束");

主线程开始
任务3: <NSThread: 0x600000276080>{number = 5, name = (null)}
任务2: <NSThread: 0x604000465740>{number = 4, name = (null)}
任务1: <NSThread: 0x604000465700>{number = 3, name = (null)}
任务0 <NSThread: 0x600000077300>{number = 1, name = main}
任务4: <NSThread: 0x600000077300>{number = 1, name = main}
主线程结束

上机打印出来的效果来看，这些任务是并行执行的，但是会阻塞主线程直到任务全部都执行完成。显然这不能满足我们的全部需求，所以我们把任务加入队列试试（加入队列任务自动执行）：

NSLog(@"主线程开始");

NSOperationQueue *queue = [NSOperationQueue new];

NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务0 %@", [NSThread currentThread]);
}];

for (int i = 1; i < 5; i ++) {
    [blockOperation addExecutionBlock:^{
        NSLog(@"任务%d %@", i, [NSThread currentThread]);
    }];
}

[queue addOperation:blockOperation];

//[blockOperation waitUntilFinished];

NSLog(@"主线程结束");

主线程开始
主线程结束
任务0 <NSThread: 0x600000475c40>{number = 3, name = (null)}
任务1 <NSThread: 0x600000475f80>{number = 5, name = (null)}
任务4 <NSThread: 0x600000475ec0>{number = 4, name = (null)}
任务3 <NSThread: 0x600000475c40>{number = 3, name = (null)}
任务2 <NSThread: 0x600000475f80>{number = 5, name = (null)}

从打印结果来看，这是并行队列+异步任务，这基本满足我们后台执行耗时任务的需求了。

你们应该也注意到了我注释了一句代码[blockOperation waitUntilFinished];，现在将它打开，运行得到的结果和方法的名字一样，它会阻塞当前线程直到任务全部结束，当然NSOperationQueue也有这么一个方法：waitUntilAllOperationsAreFinished。

maxConcurrentOperationCount

最大并发数，通过设置这个我们可以有效的控制并发任务的数量，从而对性能进行有效的控制。

（三）addDependency 添加任务依赖

我们给NSOperation添加依赖的目的，主要是实现串行队列的效果。

NSLog(@"主线程开始");

NSOperationQueue *queue = [NSOperationQueue new];

NSBlockOperation *operation0 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务1: %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];
NSBlockOperation *operation1 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务2: %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];
NSBlockOperation *operation2 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务3: %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];
NSBlockOperation *operation3 = [NSBlockOperation blockOperationWithBlock:^{
    NSLog(@"任务4: %@", [NSThread currentThread]);
    [NSThread sleepForTimeInterval:1.0];
}];

[operation1 addDependency:operation0];
[operation2 addDependency:operation1];
[operation3 addDependency:operation2];
//不要添加相互依赖。理论上不管任务在任何队列都可以添加依赖，不过不建议这么做。

[queue addOperations:@[operation0, operation1, operation2, operation3] waitUntilFinished:YES];

NSLog(@"主线程结束");

主线程开始
任务1: <NSThread: 0x604000474780>{number = 3, name = (null)}
任务2: <NSThread: 0x6040004747c0>{number = 4, name = (null)}
任务3: <NSThread: 0x604000474780>{number = 3, name = (null)}
任务4: <NSThread: 0x6040004747c0>{number = 4, name = (null)}
主线程结束

实验证明，达到了我们预期的效果，任务1到任务4都是串行执行的，并且addOperations: waitUntilFinished:方法若第二个参数为YES，会阻塞主线程。

四、锁

多线程带来的问题之一就是安全问题，“锁”是为了使多个线程间可以相互排斥地使用全局变量等共享资源，简单来说就是保证同一时刻只有一个线程访问一块代码。

下面是一个有安全问题的代码例子：

- (void)test {
    //期望操作
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self addNum];
    });
    //未预料的操作
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [self addNum];
    });
}

static int i = 0;

- (void)addNum {
    NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
    i++;
    [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
    NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
}

你只需要在你的主线程runloop中调用test就能测试了（如果目前看不明白关于线程的操作没关系，这里只是实现两个任务并行，并且模拟延长了addNum这个方法的执行时间），我们看到打印结果：

执行开始 i=0, 线程：<NSThread: 0x600000466140>{number = 5, name = (null)}
执行开始 i=0, 线程：<NSThread: 0x600000466940>{number = 4, name = (null)}
执行结束 i=2, 线程：<NSThread: 0x600000466940>{number = 4, name = (null)}
执行结束 i=2, 线程：<NSThread: 0x600000466140>{number = 5, name = (null)}

看到了么，我们无法预料异常的调用何时开始，我们期望得到的i = 1（我们的期望线程是number=4），然而却不一定能正常得到。所以，我们需要通过技术来实现共享变量的安全读写。

在介绍iOS的几种锁之前，先科普“死锁”的概念。

死锁：多线程等待一个永远无法实现的条件而无法继续执行。

1、NSLock

NSLock的使用非常简单，只需要将需要加锁的代码全部放进lock和unlock方法中。
我们修改上面的addNum代码如下：

//注意lock是一个NSLock类的全局变量lock=[NSLock new]

- (void)addNum {
    [lock lock];
    NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
    i++;
    [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
    NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
    [lock unlock];
}

同样运行程序调用test方法，打印如下：

执行开始 i=0, 线程：<NSThread: 0x600000672940>{number = 5, name = (null)}
执行结束 i=1, 线程：<NSThread: 0x600000672940>{number = 5, name = (null)}
执行开始 i=1, 线程：<NSThread: 0x60400047e580>{number = 6, name = (null)}
执行结束 i=2, 线程：<NSThread: 0x60400047e580>{number = 6, name = (null)}

作用一目了然吧，这里我们的期望线程为number=5它完整的走了执行开始和执行结束，而没有受到number=6线程的干扰（因为如果获取不到锁，number=6线程就休眠了）。

注意一：NSLock是基于POSIX线程实现的，lock和unlock都必须在同一个线程执行。
注意二：我们尽量将lock和unlock写在一起，如果业务需要导致获得锁和解锁的逻辑很分散（或者无法判断是否在同一线程），可以调用-(BOOL)tryLock方法尝试能否获取该锁，方便我们做不同的逻辑，代码如下：

- (void)addNum {
    if ([lock tryLock]) {
        NSLog(@"得到锁");
        NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
        i++;
        [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
        NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
        [lock unlock];
    } else {
        NSLog(@"没有得到锁");
    }
}

2、NSConditionLock

顾名思义，带条件的锁。同样实现了NSLocking协议，所以它的玩儿法和NSLock很像，而且它有一个方法很有意思。

lockWhenCondition:当线程A进入这里的时候，调用该方法，若不满足条件，线程就会进入休眠；若满足条件，就会得到锁并且执行下面的code。并且，若当前NSConditionLock的condition变为了满足的时候，线程A又会苏醒继续执行。当然，需要和unlockWithCondition结合使用。

下面就是一个实现多个并发任务同步执行的例子：

    NSConditionLock *clock = [[NSConditionLock alloc] initWithCondition:0];

    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [clock lockWhenCondition:0];
        NSLog(@"任务1");
        [NSThread sleepForTimeInterval:1];
        [clock unlockWithCondition:2];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [clock lockWhenCondition:1];
        NSLog(@"任务2");
        [NSThread sleepForTimeInterval:1];
        [clock unlockWithCondition:3];
    });
    dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{
        [clock lockWhenCondition:2];
        NSLog(@"任务3");
        [NSThread sleepForTimeInterval:1];
        [clock unlockWithCondition:1];
    });

打印如下：

任务1
任务3
任务2

解析：我们三个任务中都使用了lockWhenCondition方法（注意这里我用的是“任务”而非“线程”，“使用GCD线程的分配不是我们要关心的”），我们初始化锁的时候用condition=0，所以先走任务1，任务1执行完毕调用[clock unlockWithCondition:2];所以接着走任务3，同理最后走任务2。

注意：如果大量使用条件锁导致线程休眠，而开辟了过多的线程，将会对性能造成消耗，所以使用需谨慎。

3、NSRecursiveLock

我们修改一下之前的例子，当线程1获取到“锁”过后，再次调用lock。

- (void)addNum {
    [lock lock];
    [lock lock];
    NSLog(@"得到锁");
    NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
    i++;
    [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
    NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
    [lock unlock];
}

运行结果就是造成了“死锁”。还有一种常见的“死锁”的情况是：A线程获取到a锁，B线程获取到了b锁，同一时刻，A线程想要获取b锁，B线程想要获取a锁，A、B线程就会同时进入休眠（这就尴尬了）。

为了解决以上代码重复获取锁造成死锁的情况，我们引入了递归锁NSRecursiveLock。修改代码如下：

//注意：recursiveLock是一个NSRecursiveLock类型的全局变量，recursiveLock = [NSRecursiveLock new]

- (void)addNum {
    [recursiveLock lock];
    [recursiveLock lock];
    NSLog(@"得到锁");
    NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
    i++;
    [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
    NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
    [recursiveLock unlock];
    [recursiveLock unlock];
}

完美运行

注意一：使用NSRecursiveLock的时候，同样得注意获取锁和解锁需要一一对应，即一个lock对应一个unlock，不然锁不会处于可获取状态（哈哈，严谨吧，这里是不可获取状态而不是释放状态）。
注意二：若你能确定排除被重复加锁的情况，使用NSLock性能会更好。

4、@synchronized

@synchronized使用方法很简单，修改代码如下：

- (void)addNum {
    @synchronized(self){
        NSLog(@"得到锁");
        NSLog(@"执行开始 i=%d, 线程：%@", i, [NSThread currentThread]);
        i++;
        [NSThread sleepForTimeInterval:1];  //让线程阻塞一秒
        NSLog(@"执行结束 i=%d, 线程：%@", i, [NSThread currentThread]);
    }
}

@synchronized(obj)，obj参数一般指定为互斥锁要保护的对象。值得提出的是，如果同一个obj对象做为了不同@synchronized(){}的参数，则这些代码块不能同时执行。

使用@synchronized我们不用管何时获取锁、何时释放锁，更容易的实现互斥，代码更加直观清晰；但是在性能上略显不足，而且实现并行算法有些复杂，不过这些都不能影响它极高的使用率。

下面盗一张ibireme的图，来看看各种锁的性能（图中的dispatch和pthread的锁有兴趣可以了解下，对性能铭感的业务最好使用性能更好的锁）。图的来源：https://blog.ibireme.com

ibireme大神的图

“锁”从来都不是为了炫技而生，大量使用锁不仅会带来性能问题，还会让代码更加的晦涩难懂。

写在后面

多线程技术在处理并发任务以提高系统性能和用户体验方面有着至关重要的作用，在学习这些API的时候要多做尝试，而不是一味的依靠搜索引擎。