iOS 多线程及线程安全

一、多线程的基本概念

进程：可以理解成一个运行中的应用程序，是系统进行资源分配和调度的基本单位。

线程：是进程的基本执行单元，一个进程对应多个线程。

主线程：处理UI，所有更新UI的操作都必须在主线程上执行。不要把耗时操作放在主线程，会卡界面。

多线程：在同一时刻，一个CPU只能处理1条线程，但CPU可以在多条线程之间快速的切换，只要切换的足够快，就造成了多线程一同执行的假象。

线程就像火车的一节车厢，进程则是火车。车厢（线程）离开火车（进程）是无法跑动的，而火车（进程）至少有一节车厢（主线程）。多线程可以看做多个车厢，它的出现是为了提高效率。

多线程是通过提高资源使用率来提高系统总体的效率。
我们运用多线程的目的是：将耗时的操作放在后台执行！

并发与并行：《并发的艺术》中大概是这样写的，系统中有多个任务同时存在可称之为“并发”，系统内有多个任务同时执行可称之为“并行”；并发是并行的子集。比如在单核CPU系统上，只可能存在并发而不可能存在并行。

二、线程的状态与生命周期

下面分别阐述线程生命周期中的每一步

新建：实例化线程对象

就绪：向线程对象发送start消息，线程对象被加入可调度线程池等待CPU调度。

运行：CPU 负责调度可调度线程池中线程的执行。线程执行完成之前，状态可能会在就绪和运行之间来回切换。就绪和运行之间的状态变化由CPU负责，程序员不能干预。

阻塞：当满足某个预定条件时，可以使用休眠或锁，阻塞线程执行。sleepForTimeInterval（休眠指定时长），sleepUntilDate（休眠到指定日期），@synchronized(self)：（互斥锁）。

死亡：正常死亡，线程执行完毕。非正常死亡，当满足某个条件后，在线程内部中止执行/在主线程中止线程对象

还有线程的exit和cancel

[NSThread exit]：一旦强行终止线程，后续的所有代码都不会被执行。

[thread cancel]取消：并不会直接取消线程，只是给线程对象添加 isCancelled 标记。

三、多线程的四种解决方案

多线程的四种解决方案分别是：pthread（不常用），NSThread，GCD， NSOperation。

1、NSThread

// 创建线程
NSThread *thread = [[NSThread alloc] initWithTarget:self selector:@selector(run:) object:@""];

// 线程启动，事情做完了才会死， 一个NSThread对象就代表一条线程
[thread start];

//判断是否是主线程
[NSThread isMainThread]

优点：轻量级，简单易用，可以直接操作线程对象
缺点: 需要自己管理线程的生命周期、线程同步(NSLock加锁进行同步操作)。线程同步对数据的加锁会有一定的系统开销。

2、NSOperation

NSOperation是基于GCD的更高一层封装，NSOperation需要配合NSOperationQueue来实现多线程。

两种队列

NSOperationQueue只有两种队列：主队列、其他队列。非主队列（其他队列）可以实现串行或并行。

主队列的创建如下，主队列上的任务是在主线程执行的。

NSOperationQueue *mainQueue = [NSOperationQueue mainQueue];

其他队列（非主队列）的创建如下，加入到‘非队列’中的任务默认就是并发，开启多线程。

NSOperationQueue *queue = [[NSOperationQueue alloc] init];

注意：

非主队列（其他队列）可以实现串行或并行。

队列NSOperationQueue有一个参数叫做最大并发数：maxConcurrentOperationCount。

maxConcurrentOperationCount默认为-1，直接并发执行，所以加入到‘非队列’中的任务默认就是并发，开启多线程。

当maxConcurrentOperationCount为1时，则表示不开线程，也就是串行。

当maxConcurrentOperationCount大于1时，进行并发执行。

系统对最大并发数有一个限制，所以即使把maxConcurrentOperationCount设置的很大，系统也会自动调整。所以把最大并发数设置的很大是没有意义的。

子类

NSOperation是个抽象类，实际运用时中需要使用它的子类有三种方式：

使用子类NSInvocationOperation

使用子类NSBlockOperation

定义继承自NSOperation的子类，通过实现内部相应的方法来封装任务。

- (void)testOperationQueue {

    // 创建队列，默认并发

    NSOperationQueue *queue = [[NSOperationQueue alloc] init];

    // 创建操作，NSInvocationOperation

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

    // 创建操作，NSBlockOperation

    NSBlockOperation *blockOperation = [NSBlockOperation blockOperationWithBlock:^{

        for (int i = 0; i < 3; i++) {

            NSLog(@"addOperation把任务添加到队列======%@", [NSThread currentThread]);

        }

    }];

    [queue addOperation:invocationOperation];

    [queue addOperation:blockOperation];

}

- (void)invocationOperationAddOperation {

    NSLog(@"invocationOperation===aaddOperation把任务添加到队列====%@", [NSThread currentThread]);

}

运行结果如下，可以看出，任务都是在子线程执行的，开启了新线程！

依赖属性

它有一个依赖属性，某一个操作（operationB）依赖于另一个操作（operationA），只有当operationA执行完毕，才能执行operationB。

  [operationB addDependency:operationA];

取消/暂停/恢复操作

- (void)cancelAllOperations; 可以取消队列的所有操作。
- (BOOL)isSuspended; 判断队列是否处于暂停状态。 YES 为暂停状态，NO 为恢复状态。
- (void)setSuspended:(BOOL)b; 可设置操作的暂停和恢复，YES 代表暂停队列，NO 代表恢复队列。

优缺点

优点：不需要关心线程管理，数据同步的事情，可以把精力放在要执行的操作上。基于GCD，是对GCD 的封装，比GCD更加面向对象。operation 之间添加依赖关系、取消一个正在执行的 operation 、暂停和恢复 operation queue 等
缺点: NSOperation是个抽象类，使用它必须使用它的子类

3、GCD

GCD全称Grand Central Dispatch，是非常常用的多线程解决方式，核心是dispatch队列，把需要处理的任务放到dispatch block中。GCD 管理着一个线程池， 决定着dispatch block代码块将在哪个线程被执行，并且对这些线程进行管理，来缓解大量线程被创建的问题。

GCD的基本概念

同步（sync）：任务一个接着一个，前一个没有执行完，后面不能执行，不开线程。

异步（async）：开启多个新线程，任务同一时间可以一起执行。异步是多线程的代名词

最大的区别在于，同步线程要阻塞当前线程，必须要等待同步线程中的任务执行完，返回以后，才能继续执行下一任务；而异步线程则是不用等待。

阻塞一般是指：在调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会被唤醒执行后续的操作。

队列：装载线程任务的队形结构。(系统以先进先出的方式调度队列中的任务执行)。在GCD中有两种队列：串行队列和并发队列。

并发队列Concurrent Dispatch Queue：线程可以同时一起进行执行。实际上是CPU在多条线程之间快速的切换。（并发功能只有在异步（dispatch_async）函数下才有效）

串行队列Serial Dispatch Queue：线程只能依次有序的执行。

主队列的任务一定在主线程中执行

主线程可以执行主队列之外其他队列的任务.

串行与并行针对的是队列，而同步与异步，针对的则是线程。

GCD中的三种队列类型

The main queue（主线程串行队列): 与主线程功能相同，提交至Main queue的任务会在主线程中执行，

Main queue 可以通过dispatch_get_main_queue()来获取。

Global queue（全局并发队列): 全局并发队列由整个进程共享，有高、中（默认）、低、后台四个优先级别。

Global queue 可以通过调用dispatch_get_global_queue函数来获取（可以设置优先级）

    全局队列的底层是一个线程池，向全局队列中提交的 block，都会被放到这个线程池中执行，如果线程池已满，后续再提交 block 就不会再重新创建线程。等待前面的任务执行完成，才会继续执行。如果线程池中的线程长时间不结束，后续堆积的任务会越来越多，此时就会存在 APP crash的风险。

Group queue (队列组)：将多线程进行分组，最大的好处是可获知所有线程的完成情况。

Group queue 可以通过调用dispatch_group_create()来获取，通过dispatch_group_notify,可以直接监听组里所有线程完成情况。

GCD的使用

1、串行同步：当前线程顺序执行；

2、串行异步：分线程顺序执行；

3、并发同步：当前线程顺序执行；

4、并发异步：分线程无序执行；

5、主队列同步： 死锁，程序崩溃；

(参考)http://ios.jobbole.com/82622/

6、主队列异步：主线程顺序执行。

开发中关于gcd的运用：

1、开发中需要在主线程上进行UI的相关操作，通常会把一些耗时的操作放在其他线程，比如说图片文件下载等耗时操作。

2、GCD延时执行

当需要等待一会再执行一段代码时，就可以用到这个方法了：dispatch_after。

3、GCD实现代码只执行一次

使用dispatch_once能保证某段代码在程序运行过程中只被执行1次。可以用来设计单例。

4、GCD队列组

异步执行几个耗时操作，当这几个操作都完成之后再回到主线程进行操作，就可以用到队列组了。队列组有下面几个特点：

所有的任务会并发的执行(不按序)。

所有的异步函数都添加到队列中，然后再纳入队列组的监听范围。

使用dispatch_group_notify函数，来监听上面的任务是否完成，如果完成, 就会调用这个方法。

优点：轻量级的多线程解决方法，简单易用，效率高，速度快，基于C语言，更底层更高效，自动管理线程生命周期（创建线程、调度任务、销毁线程）。
缺点: 1、使用GCD的场景如果很复杂，就有非常大的可能遇到死锁问题。
2、如果想要给任务之间添加依赖关系、取消或者暂停一个正在执行的任务时就会变得非常棘手

四、多线程安全

其实是多个线程同时访问一个内存区域出现的安全问题。

解决多线程安全问题的方法 ：

一：互斥锁@synchronized(锁对象)

防止不同的线程同时获取相同的锁 。当新线程访问时，如果发现其他线程正在执行锁定的代码，新线程就会进入休眠。

NSObject *obj = [[NSObject alloc] init];

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        @synchronized(obj) {

            NSLog(@"需要线程同步的操作1 开始");

            sleep(3);

            NSLog(@"需要线程同步的操作1 结束");

        }

    });

dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0), ^{

        sleep(1);

        @synchronized(obj) {

            NSLog(@"需要线程同步的操作2");

        }

    });

@synchronized(obj)指令使用的obj为该锁的唯一标识，只有当标识相同时，才满足互斥，如果线程2中的@synchronized(obj)改为@synchronized(self),线程2就不会被阻塞，@synchronized指令实现锁的优点就是我们不需要在代码中显式的创建锁对象，便可以实现锁的机制，但作为一种预防措施，@synchronized块会隐式的添加一个异常处理来保护代码，它会在异常抛出的时候自动的释放互斥锁。

@synchronized（obj） block 会变成 objc_sync_enter 和 objc_sync_exit 的成对儿调用。 调用 objc_sync_enter(obj) 时，它用 obj 内存地址的哈希值查找合适的 SyncData，然后将其上锁。当你调用 objc_sync_exit(obj) 时，它查找合适的 SyncData 并将其解锁。

方法二：自旋锁

加了自旋锁，当新线程访问代码时，如果发现有其他线程正在锁定代码，新线程会用死循环的方式，一直等待锁定的代码执行完成。相当于不停尝试执行代码，比较消耗性能。

属性修饰atomic本身就有一把自旋锁。

下面说一下属性修饰nonatomic 和 atomic:
nonatomic 非原子属性,同一时间可以有很多线程读和写
atomic 原子属性(线程安全)，保证同一时间只有一个线程能够写入(但是同一个时间多个线程都可以取值)，atomic 本身就有一把锁(自旋锁)
atomic：线程安全，需要消耗大量的资源
nonatomic：非线程安全，不过效率更高，一般使用nonatomic

五、多线程的应用及问题思考：

NSNotification是同步还是异步?：

1、在分线程发送一个通知

dispatch_async(dispatch_get_global_queue(0, 0), ^{

        [[NSNotificationCenter defaultCenter] postNotificationName:@"test" object:self userInfo:nil];

    });

主线程监听，并进行UI操作

[[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(receiveNoti) name:@"test" object:nil];

- (void)receiveNoti {

    NSLog(@"isMainThread=%d", [NSThread isMainThread]);

    self.view.backgroundColor = [UIColor redColor];

}

结果：

isMainThread=0

=================================================================

Main Thread Checker: UI API called on a background thread: -[UIView setBackgroundColor:]

PID: 2318, TID: 88711, Thread name: (none), Queue name: com.apple.root.default-qos, QoS: 0

结论：

默认情况下，创建的NSNotification是同步的，但是发布通知的时候在子线程中，那么接收方法触发的也是在子线程中。

如何保证UI操作放在主线程中执行？

SDWebImage的SDWebImageCompat.h中有这样一个宏定义，用来保证主线程操作，为什么要这样写？

#ifndef dispatch_main_async_safe

#define dispatch_main_async_safe(block)\

    if (strcmp(dispatch_queue_get_label(DISPATCH_CURRENT_QUEUE_LABEL), dispatch_queue_get_label(dispatch_get_main_queue())) == 0) {\

        block();\

    } else {\

        dispatch_async(dispatch_get_main_queue(), block);\

    }

#endif

在此之前见到最多的是这样的：

#define dispatch_main_async_safe(block)\

    if ([NSThread isMainThread]) {\

        block();\

    } else {\

        dispatch_async(dispatch_get_main_queue(), block);\

    }

检查我们当前在主线程上执行的最简单的方法是使用[NSThread isMainThread] - GCD缺少一个类似的方便的API来检查我们是否在主队列上运行，因此许多开发人员使用了NSThread API

这在大多数情况下是有效的，直到它出现了异常。

image

潜在的问题是VektorKit API正在检查是否在主队列上调用它，而不是检查它在主线程上运行。

虽然每个应用程序都只有一个主线程，但是在这个主线程上执行许多不同的队列是可能的。

如果库(如VektorKit)依赖于在主队列上检查执行，那么从主线程上执行的非主队列调用API将导致问题。也就是说，如果在主线程执行非主队列调度的API，而这个API需要检查是否由主队列上调度，那么将会出现问题。

来源参考

SDWebImage4.0源码探究 https://www.jianshu.com/p/b8517dc833c7

iOS多线程全套：线程生命周期，多线程的四种解决方案，线程安全问题，GCD的使用，NSOperation的使用http://www.cocoachina.com/ios/20170707/19769.html

dispatch_barrier_(a)sync栅栏函数
https://blog.csdn.net/u013046795/article/details/47057585