Swift 6中全局可变Integer变量的线程安全改造方案咨询

针对你这种单线程写、多线程读的Integer全局变量场景，Swift 6里有几种简洁可靠的实现方式，以下是具体方案：

方案1：使用Swift标准库Atomic类型（推荐） #

Swift 5.10及以后（Swift 6完全支持）引入了标准库的Atomic类型，专门用于原子操作，天生线程安全，语法简洁。对于Integer类型，直接用Atomic<Int>即可：

import Atomics

let xxx = Atomic<Int>(0)

// 写入操作（单线程执行）
xxx.store(10, ordering: .relaxed)

// 读取操作（多线程安全执行）
let currentValue = xxx.load(ordering: .relaxed)

说明： #

• ordering参数：单写多读场景下用.relaxed足够，性能最优；若有复杂线程依赖，可改用.acquiring/.releasing，但此处无需额外开销。
• Atomic类型符合Sendable协议，满足Swift 6的并发安全要求，不会触发编译警告。

方案2：使用GCD读写队列实现读者写者模式 #

如果不想依赖Atomics库，也可以用GCD队列组合实现：用串行逻辑处理写入，并发队列支持多线程同时读取，通过barrier保证写入的排他性。

import Dispatch

private let xxxQueue = DispatchQueue(label: "com.example.xxxQueue", attributes: .concurrent)
private var _xxx: Int = 0

var xxx: Int {
    get {
        xxxQueue.sync {
            _xxx
        }
    }
    set {
        xxxQueue.async(flags: .barrier) {
            _xxx = newValue
        }
    }
}

// 使用方式与普通变量一致
xxx = 20 // 写入操作自动通过barrier保证排他性
let value = xxx // 多线程可同时安全读取

说明： #

• 并发队列的sync读取允许多个读操作并行执行，不互相阻塞；
• 写入用async(flags: .barrier)，会等待当前所有读操作完成后执行写入，期间其他读写请求会被阻塞，确保线程安全；
• 该方案基于Foundation框架，无需额外导入依赖。

方案3：使用os_unfair_lock（底层轻量锁） #

若追求极致性能，可使用苹果提供的轻量锁os_unfair_lock，开销比GCD队列更小：

import os

private var xxxLock = os_unfair_lock_s()
private var _xxx: Int = 0

var xxx: Int {
    get {
        os_unfair_lock_lock(&xxxLock)
        defer { os_unfair_lock_unlock(&xxxLock) }
        return _xxx
    }
    set {
        os_unfair_lock_lock(&xxxLock)
        defer { os_unfair_lock_unlock(&xxxLock) }
        _xxx = newValue
    }
}

说明： #

• os_unfair_lock在无锁状态下开销极低，适合简单整数读写场景；
• 必须保证锁的正确释放，用defer是最安全的实现方式。

内容的提问来源于stack exchange，提问作者j.s.com