swift-concurrency（Swift 并发）

Swift Concurrency Best Practices (Swift 6+)

1. Structured Concurrency

• Prefer async let for parallel tasks when the number of tasks is known.
• Use TaskGroup for a dynamic number of parallel tasks.
• Avoid Task {...} (unstructured) unless bridging from synchronous code (e.g., UI event handlers) or firing background work that outlives the scope.

2. Actors & Isolation

• Default to @MainActor for all UI-related classes (ViewModels, SwiftUI Views).
• Use actor for shared mutable state that is *not* UI-related (e.g., caching, database managers).
• Global Actors: Use @MainActor or custom global actors to synchronize access across different types.

3. Sendability

• Strict Concurrency Checking: Assume Strict Concurrency is ON.
• Mark immutable structs/enums as Sendable (often implicit, but be explicit if public).
• For classes, use final and @unchecked Sendable *only* if you are manually managing thread safety (locks/queues). Ideally, use actor.
• Closures: Ensure closures passed between contexts are @Sendable.
• TCA types: State and Reducer structs should conform to Sendable.

4. Observable Pattern

• Prefer @Observable (Observation framework) over ObservableObject + @Published.
• Pattern: @Observable public final class ViewModel.
• Combine @Observable with @MainActor when accessing UI state from async contexts.

5. Migration from Combine/Closures

• Replace DispatchQueue.main.async with await MainActor.run {...} or isolate the function itself.
• Replace Future/Promise with direct async throws functions.
• Use AsyncStream to replace simple Combine PassthroughSubject scenarios.

Example: Safe ViewModel

@Observable
@MainActor
final class UserViewModel {
    var users: [User] = []

    private let client: APIClient

    init(client: APIClient) {
        self.client = client
    }

    func load() async {
        do {
            self.users = try await client.fetchUsers()
        } catch {
            print(error)
        }
    }
}