Swift并发数据访问优化：主线程快速非阻塞读取（允许过期）+后台写入的现代化Swift Concurrency实现方案

Great question! The pain points you're describing with NSLock (boilerplate code, main thread blocking risks) are exactly why Swift Concurrency's tools like Actors and Atomics were designed. Let's break down two idiomatic, modern solutions that meet your core requirements: safe background writes, non-blocking main-thread reads (with allowed stale data), and final consistency.

方案1：Actor + 主线程缓存（推荐用于复杂状态/业务逻辑） #

This is the most idiomatic Swift Concurrency pattern for your use case, especially if you need to encapsulate business logic alongside state or manage multiple related properties. Actors inherently serialize all access to their mutable state, eliminating data races, while a main-thread cache enables lightning-fast, non-blocking reads.

核心思路 #

1. Actor作为单一真相源：All mutable state lives inside an Actor, which guarantees serial execution of all write operations (no manual locking needed).
2. 主线程维护缓存副本：The main thread holds a local copy of the state. Reads hit this copy directly (no blocking, no await).
3. 自动同步最终一致性：Subscribe to state changes in the Actor and update the main-thread cache asynchronously—ensuring the main thread eventually gets the latest value without blocking.

完整代码示例 #

// 1. Actor: 唯一的可变状态持有者，封装所有写入逻辑
actor ShapeDataStore {
    // 支持多个需要线程安全的属性
    @Published private(set) var rectangle: CGRect = .zero
    @Published private(set) var circleCenter: CGPoint = .zero
    @Published private(set) var lineWidth: CGFloat = 1.0
    
    // 写入方法：Actor串行执行，天然线程安全
    func updateRectangle(_ newValue: CGRect) {
        rectangle = newValue
    }
    
    func updateCircleCenter(_ newValue: CGPoint) {
        circleCenter = newValue
    }
    
    // 支持带业务逻辑的写入（比如验证、计算）
    func adjustLineWidth(by delta: CGFloat) {
        lineWidth = max(0.5, lineWidth + delta) // 限制最小线宽
    }
}

// 2. 主线程管理器：维护缓存，提供非阻塞读取
@MainActor
class ShapeDataManager {
    // 主线程缓存：读取时直接访问，完全非阻塞
    private(set) var cachedRectangle: CGRect = .zero
    private(set) var cachedCircleCenter: CGPoint = .zero
    private(set) var cachedLineWidth: CGFloat = 1.0
    
    private let store = ShapeDataStore()
    
    init() {
        // 初始化：同步初始值 + 订阅后续更新
        syncInitialState()
        subscribeToStoreUpdates()
    }
    
    private func syncInitialState() {
        // 异步同步初始值，不阻塞主线程
        Task {
            cachedRectangle = await store.rectangle
            cachedCircleCenter = await store.circleCenter
            cachedLineWidth = await store.lineWidth
        }
    }
    
    private func subscribeToStoreUpdates() {
        // 订阅Actor的@Published属性变化，自动同步到主线程缓存
        Task {
            for await newRect in store.$rectangle.values {
                cachedRectangle = newRect
            }
        }
        
        Task {
            for await newCenter in store.$circleCenter.values {
                cachedCircleCenter = newCenter
            }
        }
        
        Task {
            for await newWidth in store.$lineWidth.values {
                cachedLineWidth = newWidth
            }
        }
    }
    
    // 公开的安全读取属性（直接返回缓存）
    var safeRectangle: CGRect { cachedRectangle }
    var safeCircleCenter: CGPoint { cachedCircleCenter }
    var safeLineWidth: CGFloat { cachedLineWidth }
    
    // 公开的异步写入方法（调用Actor逻辑）
    func updateRectangle(_ newValue: CGRect) async {
        await store.updateRectangle(newValue)
    }
    
    func updateCircleCenter(_ newValue: CGPoint) async {
        await store.updateCircleCenter(newValue)
    }
    
    func adjustLineWidth(by delta: CGFloat) async {
        await store.adjustLineWidth(by: delta)
    }
}

// 示例使用
func exampleUsage() {
    let manager = ShapeDataManager()
    
    // 后台任务更新数据（可在任何Task/线程调用）
    Task.detached {
        await manager.updateRectangle(CGRect(x: 10, y: 10, width: 100, height: 100))
        await manager.adjustLineWidth(by: 2.0)
    }
    
    // 主线程读取数据：完全非阻塞，无锁，无await
    DispatchQueue.main.async {
        let currentRect = manager.safeRectangle
        print("Current rectangle for UI: \(currentRect)")
        // 用currentRect更新UI或处理触摸事件
    }
}

方案优势 #

• 消除样板代码：No more lock()/unlock() boilerplate—Actor handles all thread safety for writes.
• 主线程零阻塞：Reads hit a local main-thread copy directly, no locks or await required.
• 最终一致性：Main-thread cache automatically syncs with the Actor's latest state.
• 可扩展性：Easily add more properties or complex business logic to the Actor without changing the read path.

方案2：Atomic值（推荐用于简单独立值） #

If you're dealing with simple, independent value types (like CGRect, CGFloat, etc.) and want the absolute simplest, highest-performance solution, use Swift's Atomic primitives (available in Swift 5.10+ via the official swift-atomics package, or natively in newer Swift versions).

核心思路 #

Atomic operations are lock-free, thread-safe, and execute in constant time. For your use case, we use .relaxed memory ordering to allow slightly stale reads (which maximizes performance while ensuring eventual consistency).

完整代码示例 #

import Atomics // 需要通过Swift Package Manager导入swift-atomics

class RectangleManager {
    // 用Atomic包装CGRect（CGRect是Sendable，符合Atomic要求）
    private let rectangle = Atomic<CGRect>(.zero)
    
    // 安全读取：原子加载，非阻塞，允许稍微过期
    var safeRectangle: CGRect {
        rectangle.load(ordering: .relaxed)
    }
    
    // 安全写入：原子存储，线程安全
    func updateRectangle(_ newValue: CGRect) {
        rectangle.store(newValue, ordering: .relaxed)
    }
}

// 示例使用
func atomicExampleUsage() {
    let manager = RectangleManager()
    
    // 后台任务更新
    Task.detached {
        manager.updateRectangle(CGRect(x: 20, y: 20, width: 150, height: 150))
    }
    
    // 主线程读取：完全非阻塞，无锁
    DispatchQueue.main.async {
        let rect = manager.safeRectangle
        print("Atomic rectangle read: \(rect)")
    }
}

方案优势 #

• 极致简洁：Almost no boilerplate code—one-liner reads and writes.
• 最高性能：Lock-free atomic operations are faster than locks or even actors for simple values.
• 主线程零阻塞：Reads are non-blocking and execute in nanoseconds.

注意事项 #

• 仅限简单值：Best for independent value types, not complex state with interdependent properties or business logic.
• Swift版本要求：Requires Swift 5.10+ and the swift-atomics package (or native atomic support in future Swift releases).

关键最佳实践 #

1. Never block the main thread with await：Always use a main-thread cache for reads—never call await on the main thread to fetch state from an Actor (this will suspend the main thread and harm UI responsiveness).
2. Isolate mutable state：Actors are Swift's primary tool for isolating mutable state—use them to encapsulate all thread-unsafe operations.
3. Choose the right tool for the job：Use Actors for complex state/business logic, Atomics for simple independent values.
4. Embrace eventual consistency：Your requirement to allow slightly stale data is key here—this lets you avoid blocking operations entirely while ensuring the UI eventually reflects the latest state.

内容来源于stack exchange