Swift 6 동시성 완벽 가이드 — async/await부터 Actor까지

async/await 기본 패턴과 에러 처리
import Foundation

// async 함수 정의
func fetchUser(id: String) async throws -> User {
    let url = URL(string: "https://api.example.com/users/\(id)")!
    let (data, response) = try await URLSession.shared.data(from: url)

    guard let httpResponse = response as? HTTPURLResponse,
          httpResponse.statusCode == 200 else {
        throw URLError(.badServerResponse)
    }

    return try JSONDecoder().decode(User.self, from: data)
}

// 병렬 실행 — async let
func loadDashboard() async throws -> Dashboard {
    // 두 요청이 동시에 실행됨
    async let user = fetchUser(id: "1")
    async let posts = fetchPosts(userId: "1")

    // 두 결과가 모두 완료될 때까지 대기
    return Dashboard(user: try await user, posts: try await posts)
}

// Task 생성
func onButtonTap() {
    Task {
        do {
            let dashboard = try await loadDashboard()
            await updateUI(with: dashboard)
        } catch {
            print("Error: \(error)")
        }
    }
}

// Task.detached — 현재 Actor 컨텍스트와 무관하게 실행
func runInBackground() {
    Task.detached(priority: .background) {
        let result = await heavyComputation()
        // MainActor 필요 시 명시적 전환
        await MainActor.run {
            self.label.text = "\(result)"
        }
    }
}

Actor 정의와 사용 — 카운터 예시
// Actor 정의
actor Counter {
    private var value = 0

    func increment() {
        value += 1
    }

    func decrement() {
        value -= 1
    }

    var current: Int {
        value  // Actor 내부에서는 동기적 접근 가능
    }
}

// Actor 외부에서는 await 필요
let counter = Counter()

Task {
    await counter.increment()
    await counter.increment()
    let value = await counter.current
    print(value)  // 2
}

// 여러 태스크가 동시에 접근해도 안전
await withTaskGroup(of: Void.self) { group in
    for _ in 0..<1000 {
        group.addTask {
            await counter.increment()
        }
    }
}
// counter.current == 1002 (데이터 레이스 없음)

실전 패턴 — 네트워크 캐시 Actor
actor ImageCache {
    private var cache: [URL: Data] = [:]
    private var inProgress: [URL: Task<Data, Error>] = [:]

    func image(for url: URL) async throws -> Data {
        // 캐시 히트
        if let cached = cache[url] {
            return cached
        }

        // 중복 요청 방지 — 진행 중인 태스크 재사용
        if let existingTask = inProgress[url] {
            return try await existingTask.value
        }

        // 새 요청 시작
        let task = Task<Data, Error> {
            let (data, _) = try await URLSession.shared.data(from: url)
            return data
        }

        inProgress[url] = task

        do {
            let data = try await task.value
            cache[url] = data
            inProgress.removeValue(forKey: url)
            return data
        } catch {
            inProgress.removeValue(forKey: url)
            throw error
        }
    }
}

Sendable 준수 패턴 — struct, class, @unchecked
// struct는 모든 프로퍼티가 Sendable이면 자동 Sendable
struct UserProfile: Sendable {
    let id: String
    let name: String
    let score: Int
}

// class는 명시적 선언 + final + 불변 or 직렬화 보장 필요
final class ImmutableConfig: Sendable {
    let apiKey: String
    let baseURL: URL

    init(apiKey: String, baseURL: URL) {
        self.apiKey = apiKey
        self.baseURL = baseURL
    }
}

// @unchecked Sendable — 직접 동기화를 보장하는 경우
// (Lock 등을 사용하는 레거시 코드 마이그레이션 시)
final class ThreadSafeCache: @unchecked Sendable {
    private var storage: [String: Any] = [:]
    private let lock = NSLock()

    func set(_ value: Any, for key: String) {
        lock.withLock { storage[key] = value }
    }

    func get(for key: String) -> Any? {
        lock.withLock { storage[key] }
    }
}

// @Sendable 클로저
func runAsync(_ work: @Sendable @escaping () async -> Void) {
    Task { await work() }
}

@MainActor 활용 — ViewModel 패턴
import SwiftUI

// 전체 클래스를 MainActor로 격리
@MainActor
final class UserViewModel: ObservableObject {
    @Published var users: [User] = []
    @Published var isLoading = false
    @Published var errorMessage: String?

    private let service = UserService()

    func loadUsers() {
        isLoading = true
        errorMessage = nil

        Task {
            do {
                // service.fetchAll()은 백그라운드에서 실행
                let result = try await service.fetchAll()
                // 이미 @MainActor 컨텍스트이므로 바로 업데이트
                users = result
            } catch {
                errorMessage = error.localizedDescription
            }
            isLoading = false
        }
    }
}

// 특정 메서드만 MainActor로 지정
class DataProcessor {
    // 백그라운드 작업
    func process(data: [Int]) async -> [Int] {
        data.map { $0 * 2 }
    }

    // UI 업데이트만 MainActor
    @MainActor
    func updateLabel(_ text: String, on label: UILabel) {
        label.text = text
    }
}