Swift全局变量线程安全优化求助：现有方案臃肿且低效

我完全懂你的处境——全局变量确实不够优雅，但项目已经在用了，总不能一下子全重构，先解决数据竞争问题是当务之急。你用GCD在getter/setter里加逻辑的思路是对的，但代码臃肿、效率低的问题其实很容易通过统一封装+复用逻辑来解决，给你两个实用的优化方案：

方案1：单例类统一管理+GCD并发队列+屏障 #

把所有全局变量封装到一个单例类里，用同一个并发队列处理所有读写操作：读操作使用sync（保证立即返回结果），写操作加.barrier（确保写操作串行执行，且不会和读操作并发冲突）。这样既保证线程安全，又能让读操作并发执行，比纯串行队列效率更高，还能避免重复代码。

示例代码：

class GlobalStateManager {
    // 单例，确保全局只有一个实例
    static let shared = GlobalStateManager()
    private init() {}
    
    // 并发队列，所有全局变量的读写都通过这个队列
    private let stateQueue = DispatchQueue(label: "com.yourapp.global.state.queue", attributes: .concurrent)
    
    // 示例全局变量：用户Token
    private var _userToken: String?
    var userToken: String? {
        get {
            // 读操作用sync，支持并发执行
            return stateQueue.sync { _userToken }
        }
        set {
            // 写操作加barrier，串行执行，避免和读操作冲突
            stateQueue.async(flags: .barrier) { [weak self] in
                self?._userToken = newValue
            }
        }
    }
    
    // 再添加一个示例：应用主题
    private var _appTheme: String = "light"
    var appTheme: String {
        get {
            return stateQueue.sync { _appTheme }
        }
        set {
            stateQueue.async(flags: .barrier) { [weak self] in
                self?._appTheme = newValue
            }
        }
    }
}

使用时直接通过单例访问：

// 读操作
let token = GlobalStateManager.shared.userToken
// 写操作
GlobalStateManager.shared.userToken = "new_token_123"

方案2：属性包装器（Swift 5.1+）——更简洁优雅的方式 #

如果觉得单例里每个变量都写get/set还是有点重复，可以用属性包装器把线程安全逻辑彻底封装起来，之后只需要给变量加个注解就行，代码极其简洁，复用性拉满。

先实现通用的线程安全属性包装器：

@propertyWrapper
struct ThreadSafe<T> {
    private var value: T
    // 每个包装器用独立的并发队列（也可以共享队列，按需调整）
    private let queue = DispatchQueue(label: "com.yourapp.threadsafe.wrapper", attributes: .concurrent)
    
    init(wrappedValue: T) {
        self.value = wrappedValue
    }
    
    var wrappedValue: T {
        get {
            return queue.sync { value }
        }
        set {
            queue.async(flags: .barrier) { [weak self] in
                self?.value = newValue
            }
        }
    }
    
    // 额外提供modify方法，安全修改值类型（比如数组、字典）
    mutating func modify(_ closure: (inout T) -> Void) {
        queue.async(flags: .barrier) { [weak self] in
            guard let self = self else { return }
            closure(&self.value)
        }
    }
}

然后在单例（推荐用单例统一管理，避免散落在各处）里使用：

class GlobalStateManager {
    static let shared = GlobalStateManager()
    private init() {}
    
    @ThreadSafe var userToken: String?
    @ThreadSafe var appTheme: String = "light"
    @ThreadSafe var favoriteItems: [String] = []
}

修改值类型时用modify方法，避免先读后写的竞争：

// 安全地给数组添加元素
GlobalStateManager.shared.favoriteItems.modify { $0.append("new_favorite") }

为什么你的原方案会臃肿低效？ #

大概率是你给每个全局变量都单独写了GCD逻辑，甚至每个变量都创建了自己的队列——重复代码自然臃肿；如果用了串行队列处理所有操作，读操作也会被串行阻塞，效率就低了。上面两个方案都解决了这两个问题：要么共享队列复用逻辑，要么用属性包装器彻底封装重复代码，同时用并发队列+屏障让读操作并发，提升效率。

额外建议 #

虽然解决了线程安全，但全局变量的耦合性问题依然存在，后续可以考虑逐步用依赖注入或者状态管理模式（比如Combine、自己实现的状态容器）来替代全局变量，让代码更易维护。

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