MainActor

🚀 Swift 并发中的 `@MainActor` 全面解析 #

在 Swift 并发编程中，@MainActor 是保证线程安全、确保代码在主线程（Main Thread）上执行的重要工具。它在处理 UI 更新、线程同步 等场景时尤为关键，尤其适用于 SwiftUI 和 UIKit 环境。

🧩 1. 什么是 `@MainActor`？ #

@MainActor 是一种全局 actor，专门用于在主线程上执行代码。
适用于 UI 更新、数据绑定、以及必须在主线程运行的任务。
确保标记的代码不会在后台线程执行，从而避免线程安全问题。

✅ 2. `@MainActor` 的基本用法 #

📄 示例 1：修饰函数 #

import SwiftUI

@MainActor
func updateUI() {
    print("当前线程：\(Thread.isMainThread ? "主线程" : "后台线程")")
}

Task {
    await updateUI()  // 确保在主线程上执行
}

解释：
- @MainActor 修饰 updateUI，确保无论从哪个线程调用，最终都会在 主线程 上执行。
- await 确保异步代码在正确的线程调度下顺序执行。

📄 示例 2：修饰类或结构体 #

@MainActor
class ViewModel: ObservableObject {
    @Published var counter = 0

    func increment() {
        counter += 1
        print("Counter: \(counter) (线程: \(Thread.isMainThread ? "主线程" : "后台线程"))")
    }
}

let viewModel = ViewModel()

Task {
    await viewModel.increment()  // 主线程安全更新
}

关键点：
- 整个 ViewModel 类都绑定在主线程上。
- 不再担心 counter 的线程竞争或数据同步问题。

🚀 3. 在 SwiftUI 中的应用场景 #

🌟 场景 1：异步加载数据并更新 UI #

import SwiftUI

class DataLoader: ObservableObject {
    @Published var data: String = "加载中..."

    func loadData() async {
        // 模拟异步网络请求
        try? await Task.sleep(nanoseconds: 2_000_000_000)
        await updateData("数据加载完成！") // 主线程更新
    }

    @MainActor
    private func updateData(_ newData: String) {
        self.data = newData
    }
}

struct ContentView: View {
    @StateObject private var loader = DataLoader()

    var body: some View {
        VStack {
            Text(loader.data)
                .font(.title)
                .padding()

            Button("加载数据") {
                Task {
                    await loader.loadData()
                }
            }
        }
    }
}

关键逻辑：
- 异步加载数据 loadData() 在后台线程运行。
- 更新 UI 的操作 updateData() 由 @MainActor 保证在主线程执行，避免闪退或 UI 不一致问题。

🌈 场景 2：结合 `@MainActor` 与 `@Published` #

当你使用 @Published 属性时，通常需要确保数据变更发生在主线程。否则会收到警告或崩溃。

class CounterModel: ObservableObject {
    @Published var count = 0

    func increment() {
        Task {
            await MainActor.run {
                self.count += 1
            }
        }
    }
}

MainActor.run 可以在临时需要主线程执行的异步代码块中使用。

🔒 4. `@MainActor` 的高级用法 #

⚡ (1) `MainActor.run`：临时切换到主线程 #

func performBackgroundTask() async {
    print("后台线程：\(Thread.isMainThread ? "主线程" : "后台线程")")

    await MainActor.run {
        print("切换到主线程：\(Thread.isMainThread ? "主线程" : "后台线程")")
    }
}

用途：
- 当大部分任务在后台线程执行，只有一小部分需要在主线程上运行时，使用 MainActor.run 是非常高效的选择。

⚡ (2) 结合 `@Sendable` 保证线程安全 #

在并发闭包中，@MainActor 可与 @Sendable 一起使用，确保数据传递的安全性。

let closure: @Sendable () -> Void = {
    Task { @MainActor in
        print("主线程执行任务")
    }
}

closure()

这是一种现代并发编程中常见的线程安全写法，适合异步回调或多线程环境。

❌ 5. 不正确的使用方式 #

⚠️ 错误示例：未在主线程更新 UI #

class UnsafeViewModel: ObservableObject {
    @Published var message = "初始消息"

    func loadMessage() {
        Task {
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            self.message = "后台线程直接更新 UI"  // ❌ 可能导致崩溃
        }
    }
}

问题：
- 异步任务完成后，直接在后台线程更新 @Published 属性，可能导致 UI 崩溃或警告。

✅ 正确示例：使用 `@MainActor` 或 `MainActor.run` #

class SafeViewModel: ObservableObject {
    @Published var message = "初始消息"

    func loadMessage() {
        Task {
            try? await Task.sleep(nanoseconds: 1_000_000_000)
            await MainActor.run {
                self.message = "主线程安全更新 UI"  // ✅ 正确
            }
        }
    }
}

🔑 6. `@MainActor` 的底层原理 #

@MainActor 是基于 Actor 模型 实现的，确保数据的访问在单一线程（主线程）上进行。
当调用 @MainActor 修饰的代码时，Swift 的运行时会自动检查当前线程：
- 如果已经在主线程，直接执行代码。
- 如果在后台线程，自动切换到主线程再执行。

这种机制类似于 GCD 中的 DispatchQueue.main.async，但 更简洁、更安全、且与 Swift 并发模型深度集成。

📊 7. 总结 #

特性	说明
线程调度	确保代码在主线程执行，避免线程竞争问题
UI 更新	适合用于 SwiftUI 和 UIKit 中的 UI 更新
用法简洁	支持修饰函数、类、属性，或使用 `MainActor.run`
线程安全	保证 `@Published`、`ObservableObject` 等数据更新的线程安全
异步兼容	与 `async/await` 完美配合，简化异步任务管理

🎯 最佳实践 #

UI 相关逻辑统一使用 @MainActor 修饰，避免多线程导致的 UI 崩溃。
性能敏感的代码分离：仅将需要在主线程执行的部分使用 @MainActor，其他耗时任务仍应在后台线程处理。
临时切换使用 MainActor.run：不必为简单的主线程需求给整个类加上 @MainActor，局部使用更高效。
搭配 Task 使用，避免阻塞主线程，保证界面流畅性。

🚀 Swift 并发中的 @MainActor 全面解析 #

🧩 1. 什么是 @MainActor？ #

✅ 2. @MainActor 的基本用法 #