在Swift中如何设计一个同时支持值类型和引用类型的缓存机制？

题目

在Swift中如何设计一个同时支持值类型和引用类型的缓存机制？

信息

• 类型：问答
• 难度：⭐⭐

考点

值类型与引用类型,泛型协议,内存管理,线程安全

快速回答

设计一个同时支持值类型和引用类型的缓存机制需要：

• 使用泛型协议定义缓存接口，避免直接使用Any类型
• 通过关联类型约束缓存键和值
• 使用线程安全的存储结构（如DispatchQueue + Dictionary）
• 针对值类型和引用类型的不同特性设计存储策略
• 实现缓存淘汰机制（如LRU）

问题背景

在Swift中，值类型（struct/enum）和引用类型（class）有本质区别：值类型在传递时发生复制，引用类型共享实例。设计缓存时需要同时支持两种类型，并确保：

• 值类型缓存后修改原始实例不影响缓存
• 引用类型缓存后修改会影响缓存内容
• 线程安全访问

核心实现方案

1. 定义泛型缓存协议

protocol Cacheable {
    associatedtype Key: Hashable
    associatedtype Value

    func setValue(_ value: Value, forKey key: Key)
    func value(forKey key: Key) -> Value?
    func removeValue(forKey key: Key)
}

2. 实现具体缓存类

final class Cache<Key: Hashable, Value>: Cacheable {
    private var store = [Key: Value]()
    private let queue = DispatchQueue(label: "com.cache.queue", attributes: .concurrent)

    func setValue(_ value: Value, forKey key: Key) {
        queue.async(flags: .barrier) {
            self.store[key] = value
        }
    }

    func value(forKey key: Key) -> Value? {
        queue.sync { store[key] }
    }

    func removeValue(forKey key: Key) {
        queue.async(flags: .barrier) {
            self.store.removeValue(forKey: key)
        }
    }
}

关键设计要点

值类型与引用类型的处理差异

• 值类型：存入缓存时会发生复制，后续修改原始变量不影响缓存
• 引用类型：存入的是指针，修改实例属性会影响缓存内容
• 特殊处理：对于需要值语义的引用类型，可包装为Box类实现写时复制

线程安全实现

• 使用DispatchQueue的barrier标志保证写操作独占
• 读操作使用sync同步返回，避免数据竞争
• 替代方案：使用NSLock或os_unfair_lock

缓存淘汰机制示例（LRU）

final class LRUCache<Key: Hashable, Value> {
    private class Node {
        var key: Key?
        var value: Value?
        var next: Node?
        var prev: Node?
    }

    private let capacity: Int
    private var head = Node()
    private var tail = Node()
    private var nodeMap = [Key: Node]()

    init(capacity: Int) {
        self.capacity = capacity
        head.next = tail
        tail.prev = head
    }

    func get(_ key: Key) -> Value? {
        guard let node = nodeMap[key] else { return nil }
        moveToHead(node)
        return node.value
    }

    func put(_ key: Key, _ value: Value) {
        if let node = nodeMap[key] {
            node.value = value
            moveToHead(node)
            return
        }

        let newNode = Node()
        newNode.key = key
        newNode.value = value

        nodeMap[key] = newNode
        addNode(newNode)

        if nodeMap.count > capacity {
            if let last = popTail() {
                nodeMap.removeValue(forKey: last.key!)
            }
        }
    }

    // 私有方法实现节点移动逻辑
    private func addNode(_ node: Node) { ... }
    private func removeNode(_ node: Node) { ... }
    private func moveToHead(_ node: Node) { ... }
    private func popTail() -> Node? { ... }
}

最佳实践

• 类型约束：通过关联类型避免使用Any，提高类型安全
• 内存优化：对大型值类型使用indirect enum或Box包装减少复制开销
• 引用类型注意点：使用weak引用避免循环引用，特别是缓存对象时
• 性能权衡：LRU等淘汰算法会增加复杂度，根据场景选择合适策略

常见错误

• 直接使用Dictionary而不考虑线程安全导致崩溃
• 混合值/引用类型时未考虑语义差异（如修改缓存外的值类型实例）
• 忽略缓存对象的生命周期管理（特别是引用类型）
• 未实现缓存上限导致内存无限增长

扩展知识

• 写时复制(CoW)：Swift标准库对值类型的优化技术，可自定义实现
• 泛型特化：编译器优化技术，为具体类型生成专用代码
• 内存布局差异：使用MemoryLayout查看值类型和引用类型的内存占用
• Swift新特性：actor（Swift 5.5+）可简化线程安全实现