Swift Lock

并发，是编程当中一定会遇到的事情，那么并发所带来的不安全的访问随之而来，所以我们需要让这些访问顺序进行，以保证在不同的线程中安全的访问同一个资源。

在Objective-C中，我们可以用@synchronized关键字来修饰一个对象，并为其自动加上和解除 互斥锁。

- (void)myMethod:(id)anObj {
    @synchronized(anObj) {
        // 在括号内 anObj 不会被其他线程改变
    }
}

但是在Swift中，没有与之对应的方法，即@synchronized在Swift中已经（或者是暂时）不存在了。其实@synchronized在幕后做的事情是调用了objc_sync中的objc_sync_enter和objc_sync_exit方法，我们忽略掉异常的话，可以这样写：

func method(anObj: AnyObject) {
    objc_sync_enter(anObj)
    // 在 enter 和 exit 之间 anObj 不会被其他线程改变
    objc_sync_exit(anObj)
}

或者我们封装成一个闭包的形式：

func synchronized(_ lock: AnyObject, _ closure: () -> ()) {
    objc_sync_enter(lock)
    closure()
    objc_sync_exit(lock)
}

如果我们加上异常的话，stackoverflow中有一个我觉得写的比较好的方法：

func synchronized<T>(_ lock: AnyObject, _ closure: () throws -> T) rethrows -> T {
    objc_sync_enter(lock)
    defer { objc_sync_exit(lock) }
    return try closure()
}

当然了，synchronized方法，只能传递一个对象，在synchronized方法中执行的内容中的数据，是线程安全的。

我们来写一个经典的卖票Demo：

class ThreadTest {
    
    var tickets = 20
    let lock = NSLock()
    
    init() {
        let thread1 = Thread { [unowned self] in
            self?.syncSaleTickets()
        }
        thread1.name = "售票点A"
        thread1.start()
        let thread2 = Thread { [unowned self] in
            self?.syncSaleTickets()
        }
        thread2.name = "售票点B"
        thread2.start()
    }
    
    func synchronized<T>(_ lock: AnyObject, _ body: () throws -> T) rethrows -> T {
        objc_sync_enter(lock)
        defer { objc_sync_exit(lock) }
        return try body()
    }
    
    func syncSaleTickets() {
        
        while true {
            synchronized(self, { () -> Bool in
                if tickets > 0 {
                    print("\(Thread.current.name ?? ""): \(tickets)")
                    tickets -= 1
                } else {
                    print("票已卖完: \(tickets)")
                }
                return true
            })
            if tickets <= 0 {
                break
            }
        }
    }
}

打印结果：

售票点A: 20
售票点B: 19
售票点A: 18
售票点B: 17
售票点A: 16
售票点B: 15
售票点A: 14
售票点B: 13
售票点A: 12
售票点B: 11
售票点A: 10
售票点B: 9
售票点A: 8
售票点B: 7
售票点A: 6
售票点B: 5
售票点A: 4
售票点B: 3
售票点A: 2
售票点B: 1
票已卖完: 0

注意：

• 这里我们传递的参数是self，并不是tickets。

除了synchronized方法，我们还可以用NSLock这个类对一个线程进行加锁。代码看起来是这样的：

func saleTickets() {
    while true {
        if lock.try() {
            if tickets > 0 {
                print("\(Thread.current.name ?? ""): \(tickets)")
                tickets -= 1
            } else {
                print("票已卖完: \(tickets)")
                break
            }
            lock.unlock()
        }
    }
}

打印结果：

售票点A: 20
售票点B: 19
售票点A: 18
售票点B: 17
售票点A: 16
售票点B: 15
售票点A: 14
售票点B: 13
售票点A: 12
售票点B: 11
售票点A: 10
售票点B: 9
售票点A: 8
售票点B: 7
售票点A: 6
售票点B: 5
售票点A: 4
售票点B: 3
售票点A: 2
售票点B: 1
票已卖完: 0

这里也可以将if判断改成直接加锁lock.lock()。不过我认为加个判断更好。

最后：

加锁和解锁都是要消耗一定性能的，因此我们不太可能为所有的方法都加上锁。另外其实在一个 app 中可能会涉及到多线程的部分是有限的，我们也没有必要为所有东西加上锁。过多的锁不仅没有意义，而且对于多线程编程来说，可能会产生很多像死锁这样的陷阱，也难以调试。因此在使用多线程时，我们应该尽量将保持简单作为第一要务。