什麼是COW

我們都知道Swift有值型別和引用型別，而值型別在被賦值或被傳遞給函式時是會被拷貝的。在Swift中，所有的基本型別，包括整數、浮點數、字串、陣列和字典等都是值型別，並且都以結構體的形式實現。那麼，我們在寫程式碼時，這些值型別每次賦值傳遞都是會重新在記憶體裡拷貝一份嗎？

答案是否定的，想象一下，假如有個包含上千個元素的陣列，然後你把它copy一份給另一個變數，那麼Swift就要拷貝所有的元素，即使這兩個變數的陣列內容完全一樣，這對它效能來說是多麼糟糕。

The description above refers to the “copying” of strings, arrays, and dictionaries. The behavior you see in your code will always be as if a copy took place. However, Swift only performs an actual copy behind the scenes when it is absolutely necessary to do so. Swift manages all value copying to ensure optimal performance, and you should not avoid assignment to try to preempt this optimization.

而這個優化方式就是 Copy-On-Write（寫時複製），即只有當這個值需要改變時才進行復制行為。

例子

首先，讓我們看下面的例子我們更容易理解，我們建立了陣列arr1，然後將arr1賦值給arr2，再給arr2陣列新增多一個元素，我們通過檢視其地址變化來確定是否進行了拷貝行為。

let arr1 = [1, 2, 3, 4]
var arr2 = arr1
//斷點1
arr2.append(2) 
//斷點2

由於網上很多有關獲取記憶體地址的方法打印出來有差異，在此，使用lldb命令fr v -R [object] 來檢視物件記憶體結構。

斷點1位置，列印arr1, arr2

(lldb) fr v -R arr1
(Swift.Array<Swift.Int>) arr1 = {
  _buffer = {
    _storage = {
      rawValue = 0x000060400047e480 {
        Swift._ContiguousArrayStorageBase = {
          Swift._SwiftNativeNSArrayWithContiguousStorage = {
            Swift._SwiftNativeNSArray = {}
 

          }
          countAndCapacity = {
            _storage = {
              count = {
                _value = 4
              }
              _capacityAndFlags = {
                _value = 8
              }
            }
          }
        }
      }
    }
  }
}
(lldb) fr v -R arr2 
(Swift.Array<Swift.Int>) arr2 = {
  _buffer = {
    _storage = {
      rawValue = 0x000060400047e480 {
        Swift._ContiguousArrayStorageBase = {
          Swift._SwiftNativeNSArrayWithContiguousStorage = {
            Swift._SwiftNativeNSArray = {}
          }
          countAndCapacity = {
            _storage = {
              count = {
                _value = 4
              }
              _capacityAndFlags = {
                _value = 8
              }
            }
          }
        }
      }
    }
  }
}

斷點2位置，此時arr2添加了新元素，列印arr2,記憶體結構如下，我們可以看到arr2記憶體地址已經變成了0x00006000000b32c0，說明此時它們不再共享同一個例項，arr2對應的值進行了拷貝行為

(lldb) fr v -R arr2 
(Swift.Array<Swift.Int>) arr2 = {
  _buffer = {
    _storage = {
      rawValue = 0x00006000000b32c0 {
        Swift._ContiguousArrayStorageBase = {
          Swift._SwiftNativeNSArrayWithContiguousStorage = {
            Swift._SwiftNativeNSArray = {}
          }
          countAndCapacity = {
            _storage = {
              count = {
                _value = 5
              }
              _capacityAndFlags = {
                _value = 16
              }
            }
          }
        }
      }
    }
  }
}

由此可見，arr2未做修改時，arr1和arr2是共享同一個例項

具體實現

在結構體內部儲存了一個指向實際資料的引用reference，在不進行修改操作的普通傳遞過程中，都是將內部的reference的應用計數+1，在進行修改時，對內部的reference做一次copy操作，再在這個複製出來的資料進行真正的修改，防止和之前的reference產生意外的資料共享

值型別內嵌引用型別

我們已經知道值型別在不進行修改操作的普通資料傳遞時不進行拷貝行為，但是修改時就會進行拷貝行為，但是所有的值型別都是這樣的嗎，如果，這個值型別內嵌了引用型別呢？

class TestClass {
    var value: String
    init(value: String) {
        self.value = value
    }
}

struct TestStruct {
    var testClass = TestClass(value: "hello")
}

var test1 = TestStruct()
var test2 = test1

print(test1.testClass.value)
print(test2.testClass.value)
// 斷點1
test1.testClass.value = "hello world"
// 斷點2
print(test1.testClass.value)
print(test2.testClass.value)

其列印結果如下：

hello
hello
hello world
hello world

再用lldb檢視下其記憶體結構：

// 斷點1 位置 test1 和 test2 的記憶體結構 
(lldb) fr v -R test1
(TestTool.TestStruct) test1 = {
  testClass = 0x0000000101839aa0 {
    value = {
      _core = {
        _baseAddress = some {
          some = {
            _rawValue = 0x00000001005162cc "hello"
          }
        }
        _countAndFlags = {
          _value = 5
        }
        _owner = none {
          some = {
            instance_type = 0x0000000000000000
          }
        }
      }
    }
  }
}
(lldb) fr v -R test2
(TestTool.TestStruct) test2 = {
  testClass = 0x0000000101839aa0 {
    value = {
      _core = {
        _baseAddress = some {
          some = {
            _rawValue = 0x00000001005162cc "hello"
          }
        }
        _countAndFlags = {
          _value = 5
        }
        _owner = none {
          some = {
            instance_type = 0x0000000000000000
          }
        }
      }
    }
  }
}

當test1 賦值給test2 後，它們的記憶體地址都是0x0000000101839aa0，其引用型別例項變數 testClass 的地址也都是 0x00000001005162cc ，它們共享同一個例項，其引用型別的例項變數也共享

// 斷點2 位置 test1 和 test2 的記憶體結構 
(lldb) fr v -R test1
(TestTool.TestStruct) test1 = {
  testClass = 0x0000000101839aa0 {
    value = {
      _core = {
        _baseAddress = some {
          some = {
            _rawValue = 0x00000001005162c0 "hello world"
          }
        }
        _countAndFlags = {
          _value = 11
        }
        _owner = none {
          some = {
            instance_type = 0x0000000000000000
          }
        }
      }
    }
  }
}
(lldb) fr v -R test2
(TestTool.TestStruct) test2 = {
  testClass = 0x0000000101839aa0 {
    value = {
      _core = {
        _baseAddress = some {
          some = {
            _rawValue = 0x00000001005162c0 "hello world"
          }
        }
        _countAndFlags = {
          _value = 11
        }
        _owner = none {
          some = {
            instance_type = 0x0000000000000000
          }
        }
      }
    }
  }
}

而執行test1.testClass.value = "hello world" 後，test1 與 test2 的記憶體地址不變，其例項變數 testClass 地址都改變且相同，還是共享同一個例項變數，也就是說，雖然對值型別有所修改，但沒有進行拷貝行為

那麼如果直接修改整個testClass 呢？

test1.testClass = TestClass(value: "12345")

print(test1.testClass.value)
print(test2.testClass.value)

列印結果為：

12345
hello world

此時，再用lldb檢視下其記憶體結構

(lldb) fr v -R test1
(TestTool.TestStruct) test1 = {
  testClass = 0x0000000101a14de0 {
    value = {
      _core = {
        _baseAddress = some {
          some = {
            _rawValue = 0x00000001005162cc "12345"
          }
        }
        _countAndFlags = {
          _value = 5
        }
        _owner = none {
          some = {
            instance_type = 0x0000000000000000
          }
        }
      }
    }
  }
}

(lldb) fr v -R test2
(TestTool.TestStruct) test2 = {
  testClass = 0x0000000101839aa0 {
    value = {
      _core = {
        _baseAddress = some {
          some = {
            _rawValue = 0x00000001005162c0 "hello world"
          }
        }
        _countAndFlags = {
          _value = 11
        }
        _owner = none {
          some = {
            instance_type = 0x0000000000000000
          }
        }
      }
    }
  }
}

由此可見，直接修改testClass變數，test1 和test1.testClass 的記憶體地址都變化，而test2 和 test2.testClass 記憶體地址不變，說明，此時對結構體進行了拷貝行為，而testClass 這個引用型別是直接指向另一個例項，而不是對原例項進行修改

手動 COW

那麼，如何上面的值型別做到寫時複製呢?

我們可以讓testClass 私有化，讓外部無法對這個引用型別進行修改，再提供一個介面控制這個引用型別的寫入操作，如下所示：

struct TestStruct {
    private var testClass = TestClass(value: "hello")

    var testValue: String {
        get {
            return testClass.value
        }
        set {
            testClass = TestClass(value: newValue)
        }
    }
}

那麼對TestStruct這個結構體，可以通過計算型屬性testValue來控制引用型別的修改，進行修改testClass的值時，直接指向一個新的例項，而非修改，保證了其實現寫時複製

進一步優化

在Swift提供一個函式isKnownUniquelyReferenced，能檢查一個類的例項是不是唯一的引用，如果是，說明例項沒有被共享，我們就不需要對結構體例項進行復制，如果不是，說明例項被共享，這時對它進行更改就需要先複製。

對TestStruct 優化如下：

struct TestStruct {
    private var testClass = TestClass(value: "hello")

    var testValue: String {
        get {
            return testClass.value
        }
        set {
            if isKnownUniquelyReferenced(&testClass) {
                testClass.value = newValue
            }
            else {
                testClass = TestClass(value: newValue)
            }
        }
    }
}

參考