前言
昨天在优化项目性能的时候，发现了一个很有意思的现象：同样是保护共享资源的代码，有的跑得飞快，有的却慢得让人抓狂。一查才发现，原来 Swift 6 悄悄带来了一个新的同步框架（Synchronization Framework），里面的 Mutex 简直就是性能优化的神器！说实话，作为一个从 Swift 1.0 就开始写代码的老鸟，我见证了 Swift 在并发处理上的各种进化。从最开始的 GCD，到后来的 async/await，再到现在的 Actor，每一次更新都让并发编程变得更简单。但这次的 Mutex，让我有了一种"原来还能这样玩"的感觉。

今天就来聊聊这个被很多人忽视的新特性，看看它到底有什么魔力。

Swift 的锁进化史
在聊 Mutex 之前，我们先来回顾一下 Swift 中处理并发的几种方式。毕竟，知道历史才能更好地理解现在，对吧？
远古时代：NSLock 和 GCD
还记得刚开始写 iOS 的时候，要保护一个共享资源，基本就是这两种方式：

// 方式一：NSLock
class Counter {
    privatelet lock = NSLock()
    privatevarcount = 0
    
    func increment() {
        lock.lock()
        defer { lock.unlock() }
        count += 1
    }
}
// 堆代码 duidaima.com
// 方式二：串行队列
class Counter {
    privatelet queue = DispatchQueue(label: "counter.queue")
    privatevarcount = 0
    
    func increment() {
        queue.sync {
            count += 1
        }
    }
}

说实话，这两种方式都不算优雅。NSLock 容易忘记解锁（虽然有 defer 帮忙），而 GCD 的队列又显得有些重。

现代方案：Actor
Swift 5.5 引入 Actor 之后，世界变得美好了很多：

actor Counter {
    private var count = 0
    
    func increment() {
        count += 1
    }
}

这个知识点之前也有专门讲过，错过的小伙伴可以回去补一下。

Actor 介绍
代码简洁多了，而且编译器还会帮你检查并发安全。但是！Actor 有个让人头疼的地方：所有方法调用都必须是异步的。这意味着你得到处写 await，有时候真的很烦。

Mutex：新时代的性能之王
Swift 6 的 Synchronization 框架带来了 Mutex（互斥锁），它结合了传统锁的简单和现代 Swift 的安全性：

import Synchronization

final class Counter {
    privatelet mutex = Mutex(0)
    
    func increment() {
        mutex.withLock { value in
            value += 1
        }
    }
    
    func get() -> Int {
        mutex.withLock { $0 }
    }
}

看到了吗？不需要 async/await，API 简洁优雅，而且性能还特别好！

性能对比：谁是真正的王者？
我做了一个简单的测试，对比了几种不同的同步机制在高并发场景下的性能表现。测试场景是：创建 1000 万个并发任务，每个任务都对一个计数器进行累加操作。

// 测试代码
func testPerformance() async {
    letcount = 10_000_000
    let start = Date()
    
    // 创建并发任务
    await withTaskGroup(of: Void.self) { group in
        for_in0..<count {
            group.addTask {
                // 执行累加操作
            }
        }
    }
    
    let elapsed = Date().timeIntervalSince(start)
    print("耗时：\(elapsed) 秒")
}

测试结果让我大吃一惊：

同步机制	耗时（秒）	相对性能
Mutex	3.65	100% (基准)
OSAllocatedUnfairLock	4.42	83%
Actor	7.51	49%
NSLock	8.31	44%
DispatchQueue	9.28	39%

Mutex 竟然比 Actor 快了一倍多！这个结果确实让我意外。

Mutex 的使用技巧
1. 保护复杂数据结构
Mutex 不仅可以保护简单的数值，还能保护复杂的数据结构：

final class ThreadSafeCache {
    privatelet cache = Mutex([String: Data]())
    
    func set(_ key: String, value: Data) {
        cache.withLock { dict in
            dict[key] = value
        }
    }
    
    func get(_ key: String) -> Data? {
        cache.withLock { dict in
            dict[key]
        }
    }
    
    func removeAll() {
        cache.withLock { dict in
            dict.removeAll()
        }
    }
}

2. 避免死锁
使用 Mutex 最需要注意的就是避免死锁。千万不要在 withLock 的闭包里再次调用同一个 Mutex：

// ❌ 错误示例：会导致死锁
mutex.withLock { value in
    // 一些操作...
    mutex.withLock { _in// 💥 死锁！
        // ...
    }
}

// ✅ 正确做法：提取公共逻辑
privatefunc doSomething(_ value: inout Int) {
    // 共享的逻辑
}

func method1() {
    mutex.withLock { value in
        doSomething(&value)
    }
}

func method2() {
    mutex.withLock { value in
        doSomething(&value)
    }
}

3. 配合泛型使用
Mutex 支持泛型，这让它变得非常灵活：

// 创建一个线程安全的泛型容器
finalclass ThreadSafeBox<T> {
    privatelet mutex: Mutex<T>
    
    init(_ value: T) {
        self.mutex = Mutex(value)
    }
    
    func update(_ transform: (inout T) -> Void) {
        mutex.withLock { value in
            transform(&value)
        }
    }
    
    func get() -> T {
        mutex.withLock { $0 }
    }
}

// 使用示例
let box = ThreadSafeBox([1, 2, 3])
box.update { array in
    array.append(4)
}

Mutex vs Actor：如何选择？
看到这里，你可能会问：既然 Mutex 性能这么好，是不是应该抛弃 Actor 了？
其实不是的。它们各有适用场景：

使用 Mutex 的场景：
需要同步 API（不想到处写 await）
性能敏感的场景
保护简单的共享状态

与现有同步代码集成

使用 Actor 的场景：
复杂的状态管理
需要与 async/await 生态系统配合
想要编译器帮你检查并发安全
长时间运行的操作
我的建议是：对于简单的共享状态保护，优先考虑 Mutex；对于复杂的业务逻辑，Actor 仍然是更好的选择。

还有一个惊喜：Atomic
除了 Mutex，Synchronization 框架还带来了 Atomic 类型，专门用于原子操作：

import Synchronization

let counter = Atomic(0)

// 原子累加
counter.add(1, ordering: .relaxed)

// 原子读取
let value = counter.load(ordering: .relaxed)

// 比较并交换
counter.compareExchange(
    expected: 0, 
    desired: 1, 
    ordering: .relaxed
)

Atomic 的性能比 Mutex 还要好，但只能用于基本类型的简单操作。如果你只需要对数字进行原子操作，Atomic 是最佳选择。

总结
Swift 6 的 Synchronization 框架确实给我们带来了惊喜。Mutex 不仅性能出色，API 设计也很优雅，是传统锁机制在现代 Swift 中的完美进化。不过，工具终究只是工具，关键还是要根据实际场景选择合适的方案：
简单原子操作：使用 Atomic
保护共享状态：使用 Mutex
复杂异步逻辑：使用 Actor

兼容老代码：继续用 NSLock 或 GCD

你在项目中遇到过哪些并发问题？是怎么解决的？欢迎在评论区分享你的经验！