'OSSpinLock' 在 iOS 10.0 中被弃用：改用 <os/lock.h> 中的 os_unfair_lock()

Question

我经历了这个但提供的解决方案不起作用。有人可以使用 os_unfair_lock() 解释任何替代方法或正确实施吗？

当我使用'OS_UNFAIR_LOCK_INIT'时，它似乎不可用。

谢谢！

Answer 1

您可以使用 os_unfair_lock 如下，

var unfairLock = os_unfair_lock_s()

os_unfair_lock_lock(&unfairLock)
os_unfair_lock_unlock(&unfairLock)

Answer 2

在Concurrent Programming With GCD in Swift 3中，他们警告我们不能在Swift中直接使用os_unfair_lock，因为“Swift假定任何struct都可以移动了，这不适用于互斥体或锁。”

在那段视频中，演讲者建议如果您必须使用 os_unfair_lock，请将其放在 Objective-C class 中（不会移动 struct).或者如果你看一些 stdlib code, they show you can stay in Swift, but use a UnsafeMutablePointer instead of the struct directly. (Thanks to bscothern for .)

因此，例如，您可以编写一个 UnfairLock class 来避免此问题：

final class UnfairLock: NSLocking {
    private let unfairLock: UnsafeMutablePointer<os_unfair_lock> = {
        let pointer = UnsafeMutablePointer<os_unfair_lock>.allocate(capacity: 1)
        pointer.initialize(to: os_unfair_lock())
        return pointer
    }()

    deinit {
        unfairLock.deinitialize(count: 1)
        unfairLock.deallocate()
    }

    func lock() {
        os_unfair_lock_lock(unfairLock)
    }

    func tryLock() -> Bool {
        os_unfair_lock_trylock(unfairLock)
    }

    func unlock() {
        os_unfair_lock_unlock(unfairLock)
    }
}

然后您可以执行以下操作：

let lock = UnfairLock()

然后像使用 NSLock 一样使用 lock 和 unlock，但在幕后使用更高效的 os_unfair_lock：

lock.lock()
// critical section here
lock.unlock()

并且因为这符合 NSLocking，您可以使用为此设计的扩展。例如，这是我们用来保证我们的锁和解锁是平衡的常用方法：

extension NSLocking {
    func synchronized<T>(block: () throws -> T) rethrows -> T {
        lock()
        defer { unlock() }
        return try block()
    }
}

和

lock.synchronized {
    // critical section here
}

但是，最重要的是，不要使用 Swift 中的 os_unfair_lock 而不使用上述内容或 video 中预期的内容，这两者都为锁定。

'OSSpinLock' 在 iOS 10.0 中被弃用：改用 <os/lock.h> 中的 os_unfair_lock()

'OSSpinLock' was deprecated in iOS 10.0: Use os_unfair_lock() from <os/lock.h> instead

spinlock

ios

swift