并发，是编程当中一定会遇到的事情，那么并发所带来的不安全的访问随之而来，所以我们需要让这些访问顺序进行，以保证在不同的线程中安全的访问同一个资源。
在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 中可能会涉及到多线程的部分是有限的，我们也没有必要为所有东西加上锁。过多的锁不仅没有意义，而且对于多线程编程来说，可能会产生很多像死锁这样的陷阱，也难以调试。因此在使用多线程时，我们应该尽量将保持简单作为第一要务。
