在主线程上使用NSLock安全吗？

Question

我有一个全局变量，可以从多个线程访问，包括从主线程访问。我想用NSLock because it’s faster than GCD。

我想做的是：

struct SynchronizedLock<Value> {
    private var _value: Value
    private var lock = NSLock()

    init(_ value: Value) {
        self._value = value
    }

    var value: Value {
        get { lock.synchronized { _value } }
        set { lock.synchronized { _value = newValue } }
    }

    mutating func synchronized<T>(block: (inout Value) throws -> T) rethrows -> T {
        return try lock.synchronized {
            try block(&_value)
        }
    }
}

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

NSLock会阻塞主线程还是在主线程上使用它是安全的？同样，DispatchSemaphore的情况也是如此，应该使用队列吗？

Answer 1

是的，在任何线程(包括主线程)中使用NSLock是安全的。NSLock的唯一限制是您必须从锁定它的线程中解锁它，这是您在这里所做的。

会阻塞主线程，还是在主线程上使用是安全的？

显然，如果将主线程阻塞很长一段时间，就会出现问题。所以要确保你总是能很快地进出。一定要避免任何长时间的锁定(或阻塞)。

也是DispatchSemaphore的相同情况，应该使用队列吗？

任何同步机制都可以阻止使用它们的线程，因此无论同步机制如何，它都很大程度上是有问题的。DispatchSemaphore或GCD串行队列都会遇到与此锁定模式相同的问题。

您可以始终使用读写器模式，它稍微减轻了这种情况(在这种情况下，它允许并发读取，并且只允许阻止写入)。

但是，作为一般规则，限制您在同步机制中所做的工作。例如，如果您正在做一些昂贵的事情，尽可能多地在局部变量中对特定的线程执行，并且只同步共享资源的最后更新。