多线程开发在日常开发中很常见，但也很致命。
多线程之必须
网络传输，蓝牙通讯，数据库操作，文件操作等都会涉及到在子线程处理任务。能不能让他们都在主线程处理呢？答案是不行，任务放入主线程会影响用户的操作响应。因为前面说的任务类型都是需要等待/处理一段时间才能得到结果。
多线程之陷阱
多线程处理过程中经常会用到数据对象，而多线程访问数据对象就是就是一切万恶之源。
多线程数据问题本质是以下2种情况：
- 访问对象被释放。获取数据当中被释放，导致数据野指针；
- 数组大小变化，使数据越界or数据异常。数组数据个数/内容发生了变化，获取时超出数据长度或者获取到的数据跟预期不一样；
虽然知道是这两类，但实际不容易发现。最容易出问题的场景是单例。单例对象经常会保存一些数据便于大家使用，数据也会有增删改查。此时如果多线程增删改查就会出现野指针。
多线程问题之经典解法
多线程问题的核心在于数据操作非原子，解法的核心在于如何避免在修改数据时来访问数据。
以下是 3 种解法：
- 读写均加锁；
- 单独加写锁 - 栅栏；
- 同步队列or单线程；
1. 读写均加锁
此种写法简单方便，一般使用性能不错的 semphore 锁。以下是代码举例。
class LockManager {
public static let `shared` = LockManager()
// 锁
private let dataSemaphore = DispatchSemaphore(value: 1)
// 可 set get 的属性
private var name = "zhangsan"
private var age = 1
public func getName() -> String {
// 加锁
dataSemaphore.wait()
let name = self.name
// 释放锁
dataSemaphore.signal()
return name;
}
public func setName(name: String) {
// 加锁
dataSemaphore.wait()
self.name = name
// 释放锁
dataSemaphore.signal()
}
}
以下是上厕所例子。
厕所只有一个，三人去上厕所，张三先到，发现厕所没人就去后把锁挂上。此时厕所属于占用状态，后续获取厕所的李四王五都处于等待状态。此时李四的 semaphore = -1，王五 = -2。当张三使用完厕所后把锁打开并离开。此时 李四的 semaphore = 0，王五 = -1，李四获得了厕所的使用权。以此类推...
2. 单独加写锁 - 栅栏
此种方法适合写少读多的情况，性能会很好。因为读取是并发的（相当于不加锁），不像方法1是读取都加锁。
class BarrierDemoManager {
public static let `shared` = BarrierDemoManager()
// 必须自定义并发队列
private let concurrentQueue = DispatchQueue.init(label: "com.sf.barrier.manager.queue", attributes: .concurrent)
// 可 set get 的属性
private var name = "zhangsan"
public func getName() -> String {
// 不加锁
var queueName = ""
concurrentQueue.sync {
queueName = self.name
}
return queueName;
}
public func setName(name: String) {
// 加入栅栏，栅栏前加入的获取操作都必须执行完才能执行栅栏操作，栅栏后加入队列的获取操作都必须在栅栏后执行
concurrentQueue.async(flags: .barrier) { [weak self] in
guard let self = self else { return }
self.name = name
}
}
}
以下是机场入口防爆检查例子。
机场旅客流量非常大，但机场安全也十分重要。为了快速对旅客进行防爆筛查，机场对旅客进行分批次防爆安检，安检栅栏可以让大家并发的走入防爆检查区域。但到了一定人数后会通过拉横条拦住后续想进入的旅客—这相当于栅栏。栅栏的任务是对旅客进行防爆检查。检查完毕后，旅客又可以并发走出防爆区域。
3. 同步队列or单线程
同步队列或单线程的目的或者效果跟1一样，就是让操作一步一步顺序执行，先进先出，先到先得，早起鸟儿有虫吃。
关于单线程的例子不用代码举例了，咱们的主线程内的所有操作就是单线程操作。如果数据都在主线程操作也不会有多线程问题。
以下是同步队列的例子：
class SerialManager {
public static let `shared` = BarrierDemoManager()
// 必须自定义同步队列
private let serialQueue = DispatchQueue.init(label: "com.sf.barrier.manager.queue")
// 可 set get 的属性
private var name = "zhangsan"
public func getName() -> String {
// 同步 get
var queueName = ""
serialQueue.sync {
queueName = self.name
}
return queueName;
}
public func setName(name: String) {
// 同步 set
serialQueue.sync {
self.name = name
}
}
}
以上就是三种常见对多线程数据问题的处理。
栅栏封装
通常写栅栏还是相对麻烦点的，或者比较难记。这里写了一个简单的工具类及使用例子：
class BarrierHandler {
// 必须自定义并发队列
private let concurrentQueue = DispatchQueue.init(label: "com.sf.barrier.manager.queue", attributes: .concurrent)
public func doNoBarrierAction(_ action: () -> Void) {
concurrentQueue.sync {
action()
}
}
public func doBarrierAction(_ action: @escaping () -> Void) {
concurrentQueue.async(flags: .barrier) {
action()
}
}
}
class BarrierDemo2Manager {
public static let `shared` = BarrierDemo2Manager()
// BarrierHandler
private let barrierHandler = BarrierHandler()
// 可 set get 的属性
private var name = "zhangsan"
public func getName() -> String {
// 不加锁
var queueName = ""
barrierHandler.doNoBarrierAction {
queueName = self.name
}
return queueName;
}
public func setName(name: String) {
// 加入栅栏，栅栏前加入的获取操作都必须执行完才能执行栅栏操作，栅栏后加入队列的获取操作都必须在栅栏后执行
barrierHandler.doBarrierAction { [weak self] in
guard let self = self else { return }
self.name = name
}
}
}
结语
多线程问题大都都是偶现，容易被大家忽略。但量一大终究还是会蹦跶出来，希望大家在开发时多多考虑：
- 当前暴露的类的数据是否会被多线程引用，尤其是单例对象；
- 代码内多线程用到的数据是否是多线程安全；
- 锁或者队列封装的代码尽可能简洁。复杂代码内可能内部又调用了加锁，从而引发死锁；
期望大家读完后能尽量避免多线程问题，代码更健壮，人生更美丽~
