多线程开发在日常开发中很常见，但也很致命。

a8343-1el9g.gif

多线程之必须

网络传输，蓝牙通讯，数据库操作，文件操作等都会涉及到在子线程处理任务。能不能让他们都在主线程处理呢？答案是不行，任务放入主线程会影响用户的操作响应。因为前面说的任务类型都是需要等待/处理一段时间才能得到结果。

多线程之陷阱

多线程处理过程中经常会用到数据对象，而多线程访问数据对象就是就是一切万恶之源。

多线程数据问题本质是以下2种情况：

1. 访问对象被释放。获取数据当中被释放，导致数据野指针；
2. 数组大小变化，使数据越界or数据异常。数组数据个数/内容发生了变化，获取时超出数据长度或者获取到的数据跟预期不一样；

虽然知道是这两类，但实际不容易发现。最容易出问题的场景是单例。单例对象经常会保存一些数据便于大家使用，数据也会有增删改查。此时如果多线程增删改查就会出现野指针。

多线程问题之经典解法

多线程问题的核心在于数据操作非原子，解法的核心在于如何避免在修改数据时来访问数据。

以下是 3 种解法：

1. 读写均加锁；
2. 单独加写锁 - 栅栏；
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，李四获得了厕所的使用权。以此类推...

image.png

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
        }
    }
}

以下是机场入口防爆检查例子。

机场旅客流量非常大，但机场安全也十分重要。为了快速对旅客进行防爆筛查，机场对旅客进行分批次防爆安检，安检栅栏可以让大家并发的走入防爆检查区域。但到了一定人数后会通过拉横条拦住后续想进入的旅客—这相当于栅栏。栅栏的任务是对旅客进行防爆检查。检查完毕后，旅客又可以并发走出防爆区域。

image.png

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
        }
    }
}

结语

多线程问题大都都是偶现，容易被大家忽略。但量一大终究还是会蹦跶出来，希望大家在开发时多多考虑：

1. 当前暴露的类的数据是否会被多线程引用，尤其是单例对象；
2. 代码内多线程用到的数据是否是多线程安全；
3. 锁或者队列封装的代码尽可能简洁。复杂代码内可能内部又调用了加锁，从而引发死锁；

期望大家读完后能尽量避免多线程问题，代码更健壮，人生更美丽~

image.png