Swift常用的互斥锁

@synchronized是OC 中的线程互斥锁方法。Swift 对应使用 objc_sync_enter(self) 和objc_sync_exit(self)。
方法中的参数只能使 self，使用其它的不能达到互斥锁的目的。

@objc private func remove() {
        print("\(Thread.current)::\(array.count)")
        // 互斥锁
        objc_sync_enter(self)
        while array.count > 0 {
            array.removeLast()
            print("\(Thread.current)::\(array.count)")
        }
        print("\(Thread.current)::\(array.count)")
        objc_sync_exit(self)
    }

另外用信号量也比较好用，同样能达到互斥的目的
dispatch_semaphore_t是属于GCD里面的东西，dispatch_semaphore_t 和前面@synchronized一样都是OC的写法，在Swift中也不是这样写的，全部的内容都是在DispatchSemaphore中，信号量量 >=0 时候不会阻塞当前线程。信号量小于 0 时候回阻塞当前线程。wait() 信号量减1，signal() 信号量加1
DispatchSemaphore ，可以设置锁的失效时间。和初始信号量

class Test {
    // value >= 0 可以执行；每次 wait(), 信号量 -1 ；每次 signal() 信号量 + 1；
    let semaphare = DispatchSemaphore(value: 1)

    private var array: [Int] = []
    init() {
        for i in 0..<100 {
            array.append(i)
        }
    }
    func start() {
        DispatchQueue.global().async {
            self.remove()
        }
        DispatchQueue.global().async {
            self.remove()
        }
    }

    @objc private func remove() {
        print("\(Thread.current)::\(array.count)")
        // wait() 执行后信号量 -1；因为初始化为 1，减一后为 0，所以可以继续执行。
        // 如果初始信号量为0，减一后为 -1，则立即阻塞当先线程
        semaphare.wait()
        print("start")
        while array.count > 0 {
            array.removeLast()
            print("\(Thread.current)::\(array.count)")
        }
        print("\(Thread.current)::\(array.count)")
        semaphare.signal()
    }
}
let t = Test()
DispatchQueue.global().async {
    t.start()
}