Swift 中的写时复制 (Copy-on-Write) 机制

知识点图片

写时复制 (Copy-on-Write, 简称 CoW) 是 Swift 中一种非常重要的内存管理和性能优化机制。

简单来说，它的核心思想是：只有当真正需要修改数据时，才进行物理拷贝；在此之前，多个变量共享同一份内存数据。

以下是关于 Swift 中 CoW 机制的详细解析：

1. 核心概念

在 Swift 中，类型分为 值类型 (Value Types)（如 struct, enum）和 引用类型 (Reference Types)（如 class）。

理论上：当你把一个值类型赋值给另一个变量，或者作为参数传递给函数时，应该发生拷贝（Copy）。
实际上：对于像 Array、Dictionary、Set 和 String 这样的大型数据结构，如果每次赋值都进行深拷贝，性能开销会非常巨大。

CoW 就是为了解决这个问题：
当你执行 var b = a 时，Swift 并不会立即复制 a 的底层数据。a 和 b 实际上指向内存中的同一个缓冲区（Buffer）。只有当你试图修改 b（例如 b.append(1)）时，Swift 才会检测到该内存被多个变量共享，此时它会先拷贝一份数据给 b，然后在新的副本上进行修改。

2. 标准库中的 CoW 行为演示

Swift 标准库中的集合类型（Array, Dictionary, Set, String）都默认实现了 CoW。

我们可以通过打印内存地址来验证这一点：

plaintext

// 辅助函数：打印对象的内存地址
func address(of object: UnsafeRawPointer) -> String {
    let addr = Int(bitPattern: object)
    return String(format: "%p", addr)
}

// 1. 创建数组 A
var arrayA = [1, 2, 3]
print("Array A address: \(address(of: arrayA))") 

// 2. 赋值给 B (此时发生了浅拷贝，指针指向同一块内存)
var arrayB = arrayA
print("Array B address: \(address(of: arrayB))") 
// 结果：地址与 A 相同，说明没有发生物理拷贝

// 3. 修改 B (触发 Copy-on-Write)
arrayB.append(4)

// 4. 再次查看地址
print("Array A address: \(address(of: arrayA))") // A 保持不变
print("Array B address: \(address(of: arrayB))") // B 的地址变了！
// 结果：B 指向了新的内存地址

3. CoW 的工作原理

CoW 的实现依赖于 引用计数 (Reference Counting)。

共享： Array 结构体内部持有一个指向堆内存（存储实际元素）的引用。当你把 arrayA 赋值给 arrayB 时，只是复制了结构体本身（非常轻量），内部引用的引用计数 +1。
检查： 当你调用 mutating 方法（如 append）修改数组时，Swift 会检查内部引用的引用计数。
判断：
- 如果引用计数 == 1：说明只有当前变量持有该数据，直接原地修改（高效）。
- 如果引用计数 > 1：说明数据被共享，创建一个新的副本（Copy），将当前变量指向新副本，然后修改新副本（Write）。

4. 自定义类型实现 CoW

注意： Swift 中的自定义 struct 默认没有 CoW 机制。如果你在 Struct 中包含了一个引用类型（Class），简单的赋值会导致两个 Struct 指向同一个 Class 实例（浅拷贝），修改其中一个会影响另一个，这破坏了值语义。

为了让自定义 Struct 拥有高效的值语义（像 Array 一样），你需要手动实现 CoW。

关键工具是：isKnownUniquelyReferenced(_:)。

示例代码：

plaintext

// 1. 创建一个类作为底层数据存储（引用类型）
final class Ref<T> {
    var value: T
    init(_ value: T) { self.value = value }
}

// 2. 创建结构体容器
struct Box<T> {
    // 内部持有的引用
    private var ref: Ref<T>
    
    init(_ value: T) {
        self.ref = Ref(value)
    }
    
    // 计算属性读取数据
    var value: T {
        get { return ref.value }
        set {
            // 核心逻辑：在写入时检查引用唯一性
            if !isKnownUniquelyReferenced(&ref) {
                // 如果不唯一（被共享），则进行拷贝
                print("Copying...")
                ref = Ref(newValue)
            } else {
                // 如果唯一，直接修改
                print("Modifying in place...")
                ref.value = newValue
            }
        }
    }
}

// 测试
var box1 = Box(100)
var box2 = box1 // box1 和 box2 共享同一个 Ref 实例

print(box1.value) // 100
print(box2.value) // 100

box2.value = 200 // 触发 Copying...
// 此时 box2 创建了新的 Ref，box1 保持原样

print(box1.value) // 100 (未受影响，保持了值语义)
print(box2.value) // 200

box2.value = 300 // 触发 Modifying in place... (因为此时 box2 独占它的 Ref)

5. CoW 的优缺点

优点：

性能提升：减少了不必要的内存分配和数据拷贝（O(n) 操作）。
内存节省：多个只读变量共享同一份数据。
看似值类型，实则智能指针：保持了值类型简单易懂的逻辑（Value Semantics），同时拥有引用类型的效率。

缺点/注意事项：

开销：每次写入操作都需要检查引用计数，这有微小的性能损耗。
多线程陷阱：虽然标准库的 CoW 是线程安全的，但在多线程环境下频繁读写共享的 CoW 变量可能会导致竞争条件或意外的拷贝行为（因为引用计数检查不是原子性的锁）。
实现复杂：自定义类型需要手动编写样板代码。

总结

CoW 是 Swift 集合类型高性能的关键。
它通过延迟拷贝策略，在“读”时共享内存，在“写”时才分离内存。
自定义结构体默认不具备 CoW，如果结构体内部持有引用类型且需要值语义，需利用 isKnownUniquelyReferenced 手动实现。

播面