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

我有一个全局变量，可以从多个线程访问，包括从主线程访问。我想用NSLock

以下是我想做的：

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()
    }
}

struct SynchronizedLock{
私有var_值：value
私有变量锁=NSLock（）
初始值（u值：值）{
自我价值=价值
}
var值：value{
获取{lock.synchronized{{u value}}
设置{lock.synchronized{{u value=newValue}}
}
已同步的变异函数（块：（输入输出值）抛出->T）再抛出->T{
返回try lock.synchronized{
try块（&_值）
}
}
}
扩展锁定{
func已同步（块：（）抛出->T）再抛出->T{
锁（）
延迟{unlock（）}
返回try块（）
}
}

---

NSLock

是否会阻塞主线程，或者在主线程上使用是否安全？

DispatchSemaphore

也是这种情况，应该使用队列吗？

是的，从任何线程（包括主线程）使用

NSLock

都是安全的。

NSLock

的唯一限制是，您必须从锁定它的同一线程解锁它，您正在执行此操作

NSLock

是否会阻塞主线程，或者在主线程上使用是否安全

显然，如果长时间阻塞主线程，就会出现问题。所以要确保你总是很快进出。始终避免长时间锁定（或堵塞）

DispatchSemaphore

的情况也一样，应该使用队列吗

任何同步机制都会阻止使用它们的线程，因此无论采用何种同步机制，都会产生很大的问题

DispatchSemaphore

或GCD串行队列都会出现与此锁定模式相同的问题

您可以始终使用读写器模式，这稍微减轻了这一点（它允许并发读取，而只阻止写入）

---

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

这取决于您的线程如何使用它。如果是递归的，则可能需要查找NSRecursiveLock。如果不是，那么您只需要确保lock/unlock调用来自同一线程。