摘录来自: Chris Eidhof. “Swift 进阶”。

写时复制 (昂贵方式)

要实现写时复制，我们首先将 _data 标记为结构体的私有属性。我们不再直接变更 _data，而是通过一个计算属性 _dataForWriting 来访问它。这个计算属性总是会复制 _data 并将其返回：当我们调用 append 时，将会进行复制

struct MyData {
    fileprivate var _data: NSMutableData
    var _dataForWriting: NSMutableData {
        /**
         * 因为 _dataForWriting 会更改结构体 (它对 _data 属性进行了重新赋值)
         * 这个属性的 getter 需要被标记为 mutating 。
         *这意味着我们只能通过 var 的方式声明的变量来使用它。
         */
        mutating get {
            _data = _data.mutableCopy() as! NSMutableData
            return _data
        }
    }
    init(_ data: NSData) {
        self._data = data.mutableCopy() as! NSMutableData
    }
}
extension MyData {
    mutating func append(_ other: MyData) {
        /**
         *append 方法中使用了 _dataForWriting
         *所以现在 append 也需要被标记为 mutating
        */
        _dataForWriting.append(other._data as Data)
    }
}

但是每次我们调用 append 时，底层的 _data 对象都要被复制一次。因为我们没有共享 buffer 变量，所以对它进行原地变更会高效得多。

var buffer = MyData(NSData())
for _ in 0..<5 {
    buffer.append(x)
}

写时复制 (高效方式)

为了提供高效的写时复制特性，我们需要知道一个对象 (比如这里的 NSMutableData) 是否是唯一的。如果它是唯一引用，那么我们就可以直接原地修改对象。否则，我们需要在修改前创建对象的复制。

• isKnownUniquelyReferenced

在 Swift 中，我们可以使用 isKnownUniquelyReferenced 函数来检查引用的唯一性。如果你将一个 Swift 类的实例传递给这个函数，并且没有其他变量强引用这个对象的话，函数将返回 true。如果还有其他的强引用，则返回 false。对于 Objective-C 的类，它会直接返回 false。

直接对 NSMutableData 使用这个函数的话没什么意义。我们可以创建一个简单的 Swift 类，来将任意的 Objective-C 对象封装到 Swift 对象中：

final class Box<A> {
    var unbox: A
    init(_ value: A) { self.unbox = value }
}
var x = Box(NSMutableData())
isKnownUniquelyReferenced(&x) // true
如果我们有多个引用指向相同的对象，这个函数将返回 false：
var y = x
isKnownUniquelyReferenced(&x) // false

不单单是全局变量，对于结构体中的引用，这种方法也适用。有了这个方法，我们就可以重写 MyData，在发生改变前先检查对 _data 的引用是否是唯一的。我们还添加了一个 print 语句来在调试时快速查看创建复制的频度：

struct MyData {
    fileprivate var _data: Box<NSMutableData>
    var _dataForWriting: NSMutableData {
        mutating get {
            if !isKnownUniquelyReferenced(&_data) {
                _data = Box(_data.unbox.mutableCopy() as! NSMutableData)
                print("Making a copy")
            }
            return _data.unbox
        }
    }
    init(_ data: NSData) {
        self._data = Box(data.mutableCopy() as! NSMutableData)
    }
}

在 append 方法中，我们需要对 other 的 _data 属性调用 unbox。对于追加操作中原来的值进行复制的逻辑已经被封装在了 _dataForWriting 这个计算属性中了：

extension MyData {
    /**
     *append 方法中使用了 _dataForWriting
     *所以现在 append 也需要被标记为 mutating
     */
    mutating func append(_ other: MyData) {
        _dataForWriting.append(other._data.unbox as Data)
    }
}

let someBytes = MyData(NSData(base64Encoded: "wAEP/w==", options: [])!)
var empty = MyData(NSData())
var emptyCopy = empty
for _ in 0..<5 {
empty.append(someBytes)
}
empty // <c0010fff c0010fff c0010fff c0010fff c0010fff>
emptyCopy // <>

运行代码，你会看到上面加入的调试语句只在第一次调用 append 的时候被打印了一次。在接下来的循环中，引用都是唯一的，所以也就没有进行复制操作。