线程安全: 互斥锁和自旋锁(10种)

无并发,不编程.提到多线程就很难绕开锁🔐.

iOS开发中较常见的两类锁:

1. 互斥锁: 同一时刻只能有一个线程得到互斥锁,其他线程处于挂起状态.

2. 自旋锁: 当某个线程得到自旋锁后,别的线程会一直作循环,尝试加锁,当超过了限定的次数仍然没有成功得到锁时,线程也会被挂起.

自旋锁较适用于锁的持有者保存时间较短的状况下,实际使用中互斥锁会用的多一些.

1. 互斥锁,信号量

1.遵照NSLocking协议的四种锁

四种锁分别是:
NSLock、NSConditionLock、NSRecursiveLock、NSCondition

NSLocking协议

public protocol NSLocking {    
    public func lock()
    public func unlock()
}
复制代码

下面举个多个售票点同时卖票的例子

var ticket = 20
var lock = NSLock()
    
override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
    let thread1 = Thread(target: self, selector: #selector(saleTickets), object: nil)
    thread1.name = "售票点A"
    thread1.start()
    
    let thread2 = Thread(target: self, selector: #selector(saleTickets), object: nil)
    thread2.name = "售票点B"
    thread2.start()
}
	
@objc private func saleTickets() {
	while true {
	    lock.lock()
	    Thread.sleep(forTimeInterval: 0.5) // 模拟延迟
	    if ticket > 0 {
	        ticket = ticket - 1
	        print("\(String(describing: Thread.current.name!)) 卖出了一张票,当前还剩\(ticket)张票")
	        lock.unlock()
	    }else {
	        print("oh 票已经卖完了")
	        lock.unlock()
	        break;
	    }
	}
}
复制代码

遵照协议后实现的两个方法lock()和unlock(),意如其名.

除此以外NSLock、NSConditionLock、NSRecursiveLock、NSCondition四种互斥锁各有其实现:

1. 除NSCondition外,三种锁都有的两个方法:

// 尝试去锁,若是成功,返回true,不然返回false
    open func `try`() -> Bool
    // 在limit时间以前得到锁,没有返回NO
    open func lock(before limit: Date) -> Bool
复制代码

2. NSCondition条件锁:

// 当前线程挂起
    open func wait()
    // 当前线程挂起,设置一个唤醒时间
    open func wait(until limit: Date) -> Bool
    // 唤醒在等待的线程
    open func signal()
    // 唤醒全部NSCondition挂起的线程
    open func broadcast()
复制代码

当调用wait()以后,NSCondition实例会解锁已有锁的当前线程,而后再使线程休眠,当被signal()通知后,线程被唤醒,而后再给当前线程加锁,因此看起来好像wait()一直持有该锁,但根据苹果文档中说明,直接把wait()当线程锁并不能保证线程安全.

3. NSConditionLock条件锁:

NSConditionLock是借助NSCondition来实现的,在NSCondition的基础上加了限定条件,可自定义程度相对NSCondition会高些.

// 锁的时候还须要知足condition
    open func lock(whenCondition condition: Int)
    // 同try,一样须要知足condition
    open func tryLock(whenCondition condition: Int) -> Bool
    // 同unlock,须要知足condition
    open func unlock(withCondition condition: Int)
    // 同lock,须要知足condition和在limit时间以前
    open func lock(whenCondition condition: Int, before limit: Date) -> Bool
复制代码

4. NSRecurisiveLock递归锁:

定义了能够屡次给相同线程上锁并不会形成死锁的锁.

提供的几个方法和NSLock相似.

2. GCD的DispatchSemaphore和栅栏函数

1. DispatchSemaphore信号量:

DispatchSemaphore中的信号量,能够解决资源抢占的问题,支持信号的通知和等待.每当发送一个信号通知,则信号量+1;每当发送一个等待信号时信号量-1,若是信号量为0则信号会处于等待状态.直到信号量大于0开始执行.因此咱们通常将DispatchSemaphore的value设置为1.

下面给出了DispatchSemaphore的封装类

class GCDSemaphore {
    // MARK: 变量
    fileprivate var dispatchSemaphore: DispatchSemaphore!
    // MARK: 初始化
    public init() {
        dispatchSemaphore = DispatchSemaphore(value: 0)
    }
    public init(withValue: Int) {
        dispatchSemaphore = DispatchSemaphore(value: withValue)
    }
    // 执行
    public func signal() -> Bool {
        return dispatchSemaphore.signal() != 0
    }
    public func wait() {
        _ = dispatchSemaphore.wait(timeout: DispatchTime.distantFuture)
    }
    public func wait(timeoutNanoseconds: DispatchTimeInterval) -> Bool {
        if dispatchSemaphore.wait(timeout: DispatchTime.now() + timeoutNanoseconds) == DispatchTimeoutResult.success {
            return true
        } else {
            return false
        }
    }
}
复制代码

2. barrier栅栏函数:

栅栏函数也能够作线程同步,固然了这个确定是要并行队列中才能起做用.只有当当前的并行队列执行完毕,才会执行栅栏队列.

/// 建立并发队列
let queue = DispatchQueue(label: "queuename", attributes: .concurrent)
/// 异步函数
queue.async {
    for _ in 1...5 {
        print(Thread.current)
    }
}
queue.async {
    for _ in 1...5 {
        print(Thread.current)
    }
}
/// 栅栏函数
queue.async(flags: .barrier) {
    print("barrier")
}
queue.async {
    for _ in 1...5 {
        print(Thread.current)
    }
}
复制代码

3. 其余的互斥锁

1. pthread_mutex互斥锁

pthread表示POSIX thread,跨平台的线程相关的API,pthread_mutex也是一种互斥锁,互斥锁的实现原理与信号量很是类似,阻塞线程并睡眠,须要进行上下文切换.

通常状况下,一个线程只能申请一次锁,也只能在得到锁的状况下才能释放锁,屡次申请锁或释放未得到的锁都会致使崩溃.假设在已经得到锁的状况下再次申请锁,线程会由于等待锁的释放而进入睡眠状态,所以就不可能再释放锁，从而致使死锁.

这边给出了一个基于pthread_mutex_t(安全的"FIFO"互斥锁)的封装 MutexLock

1. @synchronized条件锁

平常开发中最经常使用的应该是@synchronized,这个关键字能够用来修饰一个变量,并为其自动加上和解除互斥锁.这样,能够保证变量在做用范围内不会被其余线程改变.可是在swift中它已经不存在了.其实@synchronized在幕后作的事情是调用了objc_sync中的objc_sync_enter和objc_sync_exit 方法，而且加入了一些异常判断.

所以咱们能够利用闭包本身封装一套.

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

// 使用
synchronized(lock: AnyObject) {
    // 此处AnyObject不会被其余线程改变
}

复制代码

2. 自旋锁

1. OSSpinLock自旋锁

OSSpinLock是执行效率最高的锁,不过在iOS10.0之后已经被废弃了.

详见大神ibireme的再也不安全的 OSSpinLock

2. os_unfair_lock自旋锁

它可以保证不一样优先级的线程申请锁的时候不会发生优先级反转问题.这是苹果为了取代OSSPinLock新出的一个可以避免优先级带来的死锁问题的一个锁,OSSPinLock就是有因为优先级形成死锁的问题.

注意: 这个锁适用于小场景下的一个高效锁,不然会大量消耗cpu资源.

var unsafeMutex = os_unfair_lock()
os_unfair_lock_lock(&unsafeMutex)
os_unfair_lock_trylock(&unsafeMutex)
os_unfair_lock_unlock(&unsafeMutex)
复制代码

这边给出了基于os_unfair_lock的封装 MutexLock

3. 性能比较

这边贴一张大神ibireme在iPhone六、iOS9对各类锁的性能测试图

本文收录于 SwiftTips

参考:
再也不安全的OSSpinLock
深刻理解iOS开发中的锁

若有疑问,欢迎留言 :-D