Swift 6中如何实现并发安全的静态变量？

问题说明 #

在Swift 6项目中，原Swift 4时代的网络响应缓存实现触发并发安全报错：

Static property 'cachedResponses' is not concurrency-safe because it is nonisolated global shared mutable state

根源在于全局静态可变数组cachedResponses属于非隔离共享状态，多线程同时读写会引发竞态条件，Swift 6的严格并发安全检查直接禁止了这类写法。

三种可行解决方案 #

1. Actor 原生并发隔离（推荐） #

利用Swift 5.5引入的Actor特性，天然保证状态访问的原子性和并发安全：

// 单独封装缓存逻辑到Actor中
actor NetworkResponseCache {
    private var cachedResponses: [NetworkResponse] = []
    
    func addResponse(_ response: NetworkResponse) {
        cachedResponses.append(response)
    }
    
    func clearResponses() {
        cachedResponses.removeAll()
    }
    
    func response(for request: URLRequest) -> NetworkResponse? {
        return cachedResponses.first { $0.url == request.url }
    }
}

// 在原扩展中使用Actor实例
extension NetworkRequestHandler {
    static private let cache = NetworkResponseCache()
    
    static func addResponse(_ response: NetworkResponse) async {
        await cache.addResponse(response)
    }
    
    static func clearResponses() async {
        await cache.clearResponses()
    }
    
    static func response(for request: URLRequest) async -> NetworkResponse? {
        await cache.response(for: request)
    }
}

2. GCD串行队列（传统兼容方案） #

通过串行队列将所有读写操作序列化，保证同一时间只有一个线程访问缓存：

extension NetworkRequestHandler {
    static private var cachedResponses: [NetworkResponse] = []
    // 创建专属串行队列，避免全局队列冲突
    static private let cacheQueue = DispatchQueue(label: "com.yourapp.network.response.cache")
    
    static func addResponse(_ response: NetworkResponse) {
        cacheQueue.sync {
            cachedResponses.append(response)
        }
    }
    
    static func clearResponses() {
        cacheQueue.sync {
            cachedResponses.removeAll()
        }
    }
    
    static func response(for request: URLRequest) -> NetworkResponse? {
        return cacheQueue.sync {
            cachedResponses.first { $0.url == request.url }
        }
    }
}

3. @MainActor 主线程隔离（轻量场景） #

如果缓存操作频率低、对性能影响小，可标记状态和方法为主线程隔离，利用主线程的串行特性保证安全：

extension NetworkRequestHandler {
    @MainActor static private var cachedResponses: [NetworkResponse] = []
    
    @MainActor static func addResponse(_ response: NetworkResponse) {
        cachedResponses.append(response)
    }
    
    @MainActor static func clearResponses() {
        cachedResponses.removeAll()
    }
    
    @MainActor static func response(for request: URLRequest) -> NetworkResponse? {
        return cachedResponses.first { $0.url == request.url }
    }
}

方案选型建议 #

• Actor：Swift并发模型的标准方案，适合复杂并发场景，调用时需配合async/await。
• 串行队列：无需修改调用逻辑的异步特性，适合老代码平滑迁移。
• @MainActor：适合简单场景，缺点是会占用主线程资源，不适合高频率操作。

内容的提问来源于stack exchange，提问作者cole