Swift COW 线程安全

Question

我正在研究 swift 中写时复制的工作原理。有点被 isKnownUniquelyReferenced 弄糊涂了documentation .特别是本节:

If the instance passed as object is being accessed by multiple threads simultaneously, this function may still return true. Therefore, you must only call this function from mutating methods with appropriate thread synchronization. That will ensure that isKnownUniquelyReferenced(_:) only returns true when there is really one accessor, or when there is a race condition, which is already undefined behavior.

所以想象一下。

我们有内部没有同步的 COW 结构。

拥有此结构实例并用锁保护它的类

此结构的 setter/getter

并希望安全地从这个 getter 线程返回副本

import Foundation

class StorageBuffer {
    var field: Int = 1

    init(_ field: Int) {
        self.field = field
    }

    func copy() -> StorageBuffer {
        return StorageBuffer(field)
    }
}

struct Storage {
    private var _buffer = StorageBuffer(1)

    var field: Int {
        get {
            return _buffer.field
        }
        set {
            if !isKnownUniquelyReferenced(&_buffer) {
                _buffer = _buffer.copy()
            }

            _buffer.field = newValue
        }
    }
}

class StorageAware {
    private var _storage = Storage()
    private let _storageGuard = NSLock()

    var storage: Storage {
        _storageGuard.lock()
        defer {
            _storageGuard.unlock()
        }

        return _storage
    }
}

由于真正的复制将在以后发生。同步getter就足够了吗？在这种情况下，是否有必要或结构本身是线程安全的？
任何地方都有关于 swift 线程安全的完整文档吗？

Answer 1

CoW 结构与 Int 一样线程安全，即它们不是原子的。所以就像你在修改 Int 时必须锁定并发访问一样，例如

lock.lock()
var myInt = _storedInt // lock required, not an atomic op
lock.unlock()
myInt += 1

复制 CoW 结构时，您必须执行相同的操作(您不会显示您的 _storage 本身是否被修改过，尽管它被标记为 var ，所以这表明它是 - 您需要锁定对 _storage)。

但是，当您这样做时 isKnownUniquelyReferenced如果引用是唯一的，则保证返回 true。

错误的:

var myStorage = _storage // this can race
myStorage.value = 10

对:

lock()
var myStorage = _storage // properly locked, can't race
unlock()
myStorage.value = 10 // this is safe now

错误的版本显示了文档正在谈论的种族。