야, 솔직히 말해봐. 예전에 Swift로 비동기 코드 짜다가 콜백 지옥에 빠져서 멘탈 나간 적 있지? 😅
클로저 안에 클로저, 그 안에 또 클로저... 코드가 피라미드처럼 쌓여가는 그 느낌. 거기다 스레드 안전성 문제까지 터지면 진짜 손 놓고 싶어지잖아.

근데 Apple이 Swift 5.5부터 async/await와 Actor를 들고 나타났어. 그리고 이게 진짜 게임 체인저야. 오늘은 이 녀석들을 처음부터 끝까지 제대로 파헤쳐볼 거야. 어렵게 생각하지 말고, 친구한테 설명하듯 쉽게 풀어줄게! 🎯

먼저 기초부터 잡고 가자. 비동기 프로그래밍이 왜 필요한지 모르면 async/await도 그냥 외우는 거에 불과하거든.

상상해봐. 너가 카페에서 커피를 주문했어. 두 가지 방식이 있어:

앱에서도 똑같아. 서버에서 데이터 받아오는 동안 UI가 얼어붙으면 사용자 입장에서 얼마나 짜증나겠어? 그래서 비동기 처리가 필수인 거야. 🎯

iOS 앱에서 메인 스레드는 UI 업데이트를 담당하는 유일한 스레드야. 이 친구가 바빠지면 앱이 버벅거리고, 심하면 ANR(앱 응답 없음) 상태가 돼버려.

이걸 지키면서 코드를 짜는 게 예전엔 진짜 힘들었어. GCD(Grand Central Dispatch)로 DispatchQueue.global().async 쓰고, 결과 받으면 DispatchQueue.main.async로 다시 메인으로 넘기고... 이게 반복되면 코드가 어떻게 되는지 볼까?

// 😱 예전 방식 - 콜백 지옥의 시작
func loadUserProfile(userId: String) {
    networkManager.fetchUser(userId: userId) { result in
        switch result {
        case .success(let user):
            networkManager.fetchPosts(userId: user.id) { postsResult in
                switch postsResult {
                case .success(let posts):
                    networkManager.fetchComments(postId: posts.first!.id) { commentsResult in
                        switch commentsResult {
                        case .success(let comments):
                            DispatchQueue.main.async {
                                self.updateUI(user: user, posts: posts, comments: comments)
                            }
                        case .failure(let error):
                            DispatchQueue.main.async {
                                self.showError(error)
                            }
                        }
                    }
                case .failure(let error):
                    DispatchQueue.main.async {
                        self.showError(error)
                    }
                }
            }
        case .failure(let error):
            DispatchQueue.main.async {
                self.showError(error)
            }
        }
    }
}

자, 이제 진짜 주인공 등장! Swift 5.5에서 도입된 async/await는 비동기 코드를 마치 동기 코드처럼 읽히게 만들어주는 마법이야. 위의 콜백 지옥 코드를 async/await로 바꿔보면:

// ✨ async/await 방식 - 얼마나 깔끔해!
func loadUserProfile(userId: String) async throws {
    let user = try await networkManager.fetchUser(userId: userId)
    let posts = try await networkManager.fetchPosts(userId: user.id)
    let comments = try await networkManager.fetchComments(postId: posts.first!.id)
    
    await MainActor.run {
        updateUI(user: user, posts: posts, comments: comments)
    }
}

async 키워드는 "이 함수는 비동기적으로 실행될 수 있어"라고 선언하는 거야. 함수 시그니처에서 반환 타입 앞에 붙여줘:

// 기본 async 함수
func fetchData() async -> Data {
    // 비동기 작업 수행
    return someData
}

// 에러를 던질 수 있는 async 함수
func fetchUser(id: String) async throws -> User {
    // 실패할 수 있는 비동기 작업
    return user
}

// async 함수는 async 컨텍스트에서만 호출 가능!
func someAsyncFunction() async {
    let data = await fetchData()           // await 필수!
    let user = try await fetchUser(id: "1") // throws + async = try await
}

await는 "이 비동기 작업이 완료될 때까지 여기서 일시 정지할게"라는 의미야. 중요한 건 스레드를 블로킹하지 않는다는 거야!

// await의 동작을 이해하는 예시
func processImages() async {
    print("1. 이미지 처리 시작")
    
    // 여기서 일시 중단 - 스레드는 다른 일 처리
    let image = await downloadImage(url: imageURL)
    
    // 다운로드 완료 후 재개
    print("2. 이미지 다운로드 완료")
    
    // 또 일시 중단
    let processed = await applyFilter(to: image)
    
    // 필터 적용 완료 후 재개
    print("3. 필터 적용 완료")
    
    await saveImage(processed)
    print("4. 저장 완료!")
}

기존에 completion handler 방식으로 작성된 코드를 async/await로 변환할 때는 withCheckedContinuation이나 withCheckedThrowingContinuation을 사용해:

// 기존 completion handler 방식
func oldFetchData(completion: @escaping (Result<Data, Error>) -> Void) {
    URLSession.shared.dataTask(with: url) { data, response, error in
        if let error = error {
            completion(.failure(error))
        } else if let data = data {
            completion(.success(data))
        }
    }.resume()
}

// async/await 래퍼로 변환
func fetchData() async throws -> Data {
    return try await withCheckedThrowingContinuation { continuation in
        oldFetchData { result in
            switch result {
            case .success(let data):
                continuation.resume(returning: data)
            case .failure(let error):
                continuation.resume(throwing: error)
            }
        }
    }
}

// 이제 깔끔하게 사용 가능!
func loadContent() async throws {
    let data = try await fetchData()
    // data 사용...
}

async/await를 배웠으면 이제 Task를 알아야 해. Task는 비동기 작업의 기본 단위야. 동기 컨텍스트에서 비동기 코드를 실행하거나, 여러 작업을 동시에 실행할 때 사용해.

// 동기 컨텍스트에서 비동기 코드 실행
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        // Task로 비동기 작업 시작
        Task {
            do {
                let user = try await fetchUser(id: "123")
                // UI 업데이트는 메인 스레드에서!
                await MainActor.run {
                    self.updateUI(with: user)
                }
            } catch {
                print("에러 발생: \(error)")
            }
        }
    }
}

// Task에 우선순위 설정
Task(priority: .high) {
    await importantWork()
}

Task(priority: .background) {
    await lowPriorityWork()
}

여러 비동기 작업을 동시에 실행하고 싶을 때 async let을 써봐. 이게 진짜 강력해!

// ❌ 순차 실행 - 총 3초 소요 (1초 + 1초 + 1초)
func loadDataSequentially() async throws {
    let user = try await fetchUser()        // 1초 기다림
    let posts = try await fetchPosts()      // 1초 기다림
    let settings = try await fetchSettings() // 1초 기다림
    
    updateUI(user: user, posts: posts, settings: settings)
}

// ✅ 병렬 실행 - 총 1초 소요 (동시에 실행!)
func loadDataInParallel() async throws {
    async let user = fetchUser()        // 시작만 하고 넘어감
    async let posts = fetchPosts()      // 시작만 하고 넘어감
    async let settings = fetchSettings() // 시작만 하고 넘어감
    
    // 여기서 세 작업 모두 완료될 때까지 기다림
    let (u, p, s) = try await (user, posts, settings)
    
    updateUI(user: u, posts: p, settings: s)
}

작업 개수가 런타임에 결정되는 경우엔 TaskGroup을 써야 해. 예를 들어 이미지 배열을 받아서 모두 다운로드해야 할 때:

// TaskGroup으로 동적 병렬 처리
func downloadImages(urls: [URL]) async throws -> [UIImage] {
    return try await withThrowingTaskGroup(of: UIImage.self) { group in
        // 각 URL에 대해 Task 추가
        for url in urls {
            group.addTask {
                return try await downloadImage(from: url)
            }
        }
        
        // 모든 결과 수집
        var images: [UIImage] = []
        for try await image in group {
            images.append(image)
        }
        return images
    }
}

// 에러 없는 버전
func processItems(items: [Item]) async -> [ProcessedItem] {
    return await withTaskGroup(of: ProcessedItem.self) { group in
        for item in items {
            group.addTask {
                return await processItem(item)
            }
        }
        
        var results: [ProcessedItem] = []
        for await result in group {
            results.append(result)
        }
        return results
    }
}

Task는 취소할 수 있어. 예를 들어 사용자가 화면을 떠났을 때 진행 중인 네트워크 요청을 취소하고 싶다면:

class ImageLoader: ObservableObject {
    private var loadingTask: Task<Void, Never>?
    
    func loadImage(url: URL) {
        // 기존 Task 취소
        loadingTask?.cancel()
        
        // 새 Task 시작
        loadingTask = Task {
            do {
                let image = try await downloadImage(from: url)
                
                // 취소됐는지 확인
                guard !Task.isCancelled else { return }
                
                await MainActor.run {
                    self.image = image
                }
            } catch is CancellationError {
                print("작업이 취소됐어!")
            } catch {
                print("에러: \(error)")
            }
        }
    }
    
    func cancelLoading() {
        loadingTask?.cancel()
    }
}

// 취소 가능한 작업 작성 시 주의사항
func longRunningWork() async throws {
    for i in 0..<1000 {
        // 주기적으로 취소 여부 확인!
        try Task.checkCancellation()
        
        await processItem(i)
    }
}

자, 이제 진짜 핵심 중의 핵심! Actor야. 멀티스레드 환경에서 가장 골치 아픈 문제가 뭔지 알아? 바로 데이터 레이스(Data Race)야.

두 스레드가 동시에 같은 데이터에 접근하는데, 그 중 하나 이상이 쓰기 작업을 할 때 발생해. 결과가 예측 불가능해지고, 버그 재현도 어렵고, 디버깅은 지옥이야 😈

// 😱 데이터 레이스 예시 - 이런 코드 절대 쓰면 안 돼!
class BankAccount {
    var balance: Int = 1000
    
    func deposit(amount: Int) {
        // 여러 스레드가 동시에 이 코드를 실행하면?
        let current = balance    // 스레드 A: 1000 읽음
                                 // 스레드 B: 1000 읽음 (동시에!)
        balance = current + amount // 스레드 A: 1100 씀
                                   // 스레드 B: 1100 씀 (200 입금했는데 100만 반영!)
    }
}

// 두 스레드가 동시에 100씩 입금하면 결과가 1200이어야 하는데
// 데이터 레이스로 인해 1100이 될 수 있어!

Actor는 class처럼 참조 타입이지만, 내부 상태에 대한 접근을 직렬화(serialize)해서 한 번에 하나의 작업만 처리하도록 보장해:

// ✅ Actor로 안전한 BankAccount
actor BankAccount {
    private(set) var balance: Int = 1000
    
    func deposit(amount: Int) {
        balance += amount  // Actor가 직렬화 보장!
    }
    
    func withdraw(amount: Int) throws {
        guard balance >= amount else {
            throw BankError.insufficientFunds
        }
        balance -= amount
    }
    
    func transfer(amount: Int, to other: BankAccount) async throws {
        try withdraw(amount: amount)
        await other.deposit(amount: amount)  // 다른 Actor 접근 시 await 필요!
    }
}

// Actor 사용
let account = BankAccount()

Task {
    await account.deposit(amount: 500)
    print(await account.balance)  // 프로퍼티 접근도 await!
}

Task {
    try await account.withdraw(amount: 200)
}

Actor 내부의 모든 메서드가 격리(isolation)될 필요는 없어. 공유 상태에 접근하지 않는 메서드는 nonisolated로 표시하면 await 없이 호출 가능해:

actor UserManager {
    private var users: [String: User] = [:]
    var name: String = "UserManager"
    
    // 격리된 메서드 - await 필요
    func addUser(_ user: User) {
        users[user.id] = user
    }
    
    // nonisolated - await 불필요, 공유 상태 접근 안 함
    nonisolated func greet() -> String {
        return "안녕하세요! UserManager입니다."
    }
    
    // nonisolated - 계산만 하고 상태 변경 없음
    nonisolated func formatUserId(_ id: String) -> String {
        return "USER_\(id.uppercased())"
    }
}

// 사용
let manager = UserManager()
print(manager.greet())           // await 불필요!
print(manager.formatUserId("abc")) // await 불필요!
await manager.addUser(someUser)   // await 필요

@MainActor는 특별한 전역 Actor야. 메인 스레드에서만 실행되도록 보장해줘. UI 업데이트에 필수적이야!

// @MainActor 클래스 - 모든 메서드가 메인 스레드에서 실행
@MainActor
class ViewModel: ObservableObject {
    @Published var isLoading = false
    @Published var users: [User] = []
    @Published var errorMessage: String?
    
    func loadUsers() async {
        isLoading = true  // 메인 스레드 보장!
        
        do {
            // 백그라운드에서 네트워크 요청
            let fetchedUsers = try await UserService.fetchUsers()
            
            // 결과를 메인 스레드에서 처리 (자동!)
            users = fetchedUsers
        } catch {
            errorMessage = error.localizedDescription
        }
        
        isLoading = false  // 메인 스레드 보장!
    }
}

// 특정 메서드만 @MainActor 지정
class DataManager {
    func fetchData() async throws -> [Item] {
        // 백그라운드에서 실행
        return try await networkCall()
    }
    
    @MainActor
    func updateUI(with items: [Item]) {
        // 메인 스레드에서만 실행
        tableView.reloadData()
    }
}

// 코드 블록을 메인 스레드에서 실행
func someFunction() async {
    let data = await fetchData()
    
    await MainActor.run {
        // 이 블록은 메인 스레드에서 실행
        label.text = "완료!"
        spinner.stopAnimating()
    }
}

Actor를 쓰다 보면 Sendable이라는 프로토콜을 만나게 될 거야. 이게 뭔지 알아야 Actor를 제대로 쓸 수 있어!

Actor 경계를 넘어서 데이터를 전달할 때, 그 데이터가 안전한지 컴파일러가 검증해야 해. Sendable은 "나는 여러 스레드에서 안전하게 사용될 수 있어"라는 약속이야:

// Sendable 프로토콜 채택
struct UserProfile: Sendable {
    let id: String
    let name: String
    let age: Int
    // 모든 프로퍼티가 Sendable이면 자동으로 Sendable
}

// 값 타입(struct, enum)은 대부분 자동으로 Sendable
struct Point: Sendable {
    var x: Double
    var y: Double
}

// 클래스는 명시적으로 선언 + 조건 충족 필요
final class ImmutableConfig: Sendable {
    let apiKey: String  // let만 사용 (불변)
    let baseURL: URL
    
    init(apiKey: String, baseURL: URL) {
        self.apiKey = apiKey
        self.baseURL = baseURL
    }
}

// @unchecked Sendable - 직접 스레드 안전성 보장할 때
final class ThreadSafeCache: @unchecked Sendable {
    private var cache: [String: Any] = [:]
    private let lock = NSLock()
    
    func set(_ value: Any, for key: String) {
        lock.lock()
        defer { lock.unlock() }
        cache[key] = value
    }
    
    func get(for key: String) -> Any? {
        lock.lock()
        defer { lock.unlock() }
        return cache[key]
    }
}

데이터가 한 번에 오는 게 아니라 스트림처럼 흘러올 때 어떻게 처리할까? 바로 AsyncSequence야! 파일 읽기, 웹소켓, 알림 스트림 등에 딱이야.

// AsyncSequence 기본 사용
func processNotifications() async {
    // for await in으로 비동기 스트림 처리
    for await notification in NotificationCenter.default.notifications(named: .someNotification) {
        handleNotification(notification)
    }
}

// URL 응답을 스트림으로 처리
func downloadLargeFile(url: URL) async throws {
    let (bytes, response) = try await URLSession.shared.bytes(from: url)
    
    var receivedData = Data()
    for try await byte in bytes {
        receivedData.append(byte)
        
        // 진행률 업데이트
        let progress = Double(receivedData.count) / Double(response.expectedContentLength)
        await updateProgress(progress)
    }
    
    await processData(receivedData)
}

// 파일 라인 단위 읽기
func processLogFile(url: URL) async throws {
    let fileHandle = try FileHandle(forReadingFrom: url)
    
    for try await line in fileHandle.bytes.lines {
        processLogLine(line)
    }
}

직접 비동기 스트림을 만들고 싶을 때는 AsyncStream을 써:

// AsyncStream으로 위치 업데이트 스트림 만들기
func locationUpdates() -> AsyncStream<CLLocation> {
    return AsyncStream { continuation in
        let locationManager = CLLocationManager()
        let delegate = LocationDelegate { location in
            continuation.yield(location)  // 새 값 전달
        }
        locationManager.delegate = delegate
        locationManager.startUpdatingLocation()
        
        // 스트림 종료 시 정리
        continuation.onTermination = { _ in
            locationManager.stopUpdatingLocation()
        }
    }
}

// 사용
func trackLocation() async {
    for await location in locationUpdates() {
        print("현재 위치: \(location.coordinate)")
        
        if shouldStop {
            break  // 스트림 종료
        }
    }
}

// AsyncThrowingStream - 에러 발생 가능한 스트림
func dataStream() -> AsyncThrowingStream<Data, Error> {
    return AsyncThrowingStream { continuation in
        Task {
            do {
                for i in 0..<10 {
                    let data = try await fetchChunk(index: i)
                    continuation.yield(data)
                }
                continuation.finish()  // 정상 종료
            } catch {
                continuation.finish(throwing: error)  // 에러로 종료
            }
        }
    }
}

이론은 충분히 배웠으니까 이제 실제로 어떻게 쓰는지 패턴별로 알아보자. 재능넷 같은 플랫폼을 만든다고 가정하고 예시를 들어볼게! 🎨

// 프로토콜 정의
protocol UserRepositoryProtocol {
    func fetchUser(id: String) async throws -> User
    func updateUser(_ user: User) async throws
    func deleteUser(id: String) async throws
}

// 실제 구현
actor UserRepository: UserRepositoryProtocol {
    private let networkService: NetworkService
    private var cache: [String: User] = [:]
    
    init(networkService: NetworkService) {
        self.networkService = networkService
    }
    
    func fetchUser(id: String) async throws -> User {
        // 캐시 확인
        if let cached = cache[id] {
            return cached
        }
        
        // 네트워크 요청
        let user = try await networkService.get("/users/\(id)", as: User.self)
        cache[id] = user  // 캐시 저장 (Actor가 안전하게 보장!)
        return user
    }
    
    func updateUser(_ user: User) async throws {
        try await networkService.put("/users/\(user.id)", body: user)
        cache[user.id] = user  // 캐시 업데이트
    }
    
    func deleteUser(id: String) async throws {
        try await networkService.delete("/users/\(id)")
        cache.removeValue(forKey: id)  // 캐시에서 제거
    }
}

// SwiftUI ViewModel
@MainActor
class TalentListViewModel: ObservableObject {
    @Published var talents: [Talent] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    @Published var searchQuery = ""
    
    private let repository: TalentRepository
    private var searchTask: Task<Void, Never>?
    
    init(repository: TalentRepository) {
        self.repository = repository
    }
    
    func loadTalents() async {
        isLoading = true
        errorMessage = nil
        
        do {
            talents = try await repository.fetchTalents()
        } catch {
            errorMessage = "재능 목록을 불러오는데 실패했어요: \(error.localizedDescription)"
        }
        
        isLoading = false
    }
    
    func search(query: String) {
        // 이전 검색 취소
        searchTask?.cancel()
        
        searchTask = Task {
            // 디바운싱 - 0.3초 대기
            try? await Task.sleep(nanoseconds: 300_000_000)
            
            guard !Task.isCancelled else { return }
            
            do {
                talents = try await repository.searchTalents(query: query)
            } catch is CancellationError {
                // 취소된 경우 무시
            } catch {
                errorMessage = error.localizedDescription
            }
        }
    }
    
    func loadMoreIfNeeded(currentItem: Talent) async {
        guard let lastItem = talents.last,
              lastItem.id == currentItem.id else { return }
        
        // 페이지네이션
        do {
            let moreTalents = try await repository.fetchNextPage()
            talents.append(contentsOf: moreTalents)
        } catch {
            print("추가 로드 실패: \(error)")
        }
    }
}

// 재시도 가능한 네트워크 요청
func fetchWithRetry<T>(
    maxAttempts: Int = 3,
    delay: Duration = .seconds(1),
    operation: () async throws -> T
) async throws -> T {
    var lastError: Error?
    
    for attempt in 1...maxAttempts {
        do {
            return try await operation()
        } catch {
            lastError = error
            
            // 마지막 시도가 아니면 대기 후 재시도
            if attempt < maxAttempts {
                print("시도 \(attempt) 실패, \(delay)후 재시도...")
                try await Task.sleep(for: delay)
            }
        }
    }
    
    throw lastError!
}

// 사용 예시
func loadUserData(id: String) async throws -> User {
    return try await fetchWithRetry(maxAttempts: 3, delay: .seconds(2)) {
        try await userRepository.fetchUser(id: id)
    }
}

// 타임아웃 처리
func withTimeout<T>(
    seconds: Double,
    operation: @escaping () async throws -> T
) async throws -> T {
    return try await withThrowingTaskGroup(of: T.self) { group in
        // 실제 작업
        group.addTask {
            return try await operation()
        }
        
        // 타임아웃 Task
        group.addTask {
            try await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
            throw TimeoutError()
        }
        
        // 먼저 완료된 결과 반환
        let result = try await group.next()!
        group.cancelAll()  // 나머지 Task 취소
        return result
    }
}

struct TimeoutError: Error {
    var localizedDescription: String { "요청 시간이 초과됐어요!" }
}

// 사용
func fetchWithTimeout() async throws -> Data {
    return try await withTimeout(seconds: 10) {
        try await networkService.fetchLargeData()
    }
}

// 앱 전체 상태 관리
actor AppStateManager {
    static let shared = AppStateManager()
    
    private var currentUser: User?
    private var authToken: String?
    private var settings: AppSettings = AppSettings()
    
    private init() {}
    
    // 로그인
    func login(email: String, password: String) async throws {
        let response = try await AuthService.login(email: email, password: password)
        currentUser = response.user
        authToken = response.token
        
        // 토큰 저장
        await KeychainManager.shared.save(token: response.token)
    }
    
    // 로그아웃
    func logout() async {
        currentUser = nil
        authToken = nil
        await KeychainManager.shared.deleteToken()
    }
    
    // 현재 사용자 가져오기
    func getCurrentUser() -> User? {
        return currentUser
    }
    
    // 인증 토큰 가져오기
    func getAuthToken() -> String? {
        return authToken
    }
    
    // 설정 업데이트
    func updateSettings(_ newSettings: AppSettings) async {
        settings = newSettings
        await SettingsStorage.save(settings)
    }
}

// 사용
Task {
    do {
        try await AppStateManager.shared.login(email: "user@example.com", password: "password")
        let user = await AppStateManager.shared.getCurrentUser()
        print("로그인 성공: \(user?.name ?? "")")
    } catch {
        print("로그인 실패: \(error)")
    }
}

비동기 코드에서 에러 처리는 정말 중요해. async/await 덕분에 에러 처리가 훨씬 깔끔해졌는데, 제대로 알고 써야 해!

// 잘 설계된 에러 타입
enum NetworkError: Error, LocalizedError {
    case invalidURL
    case noConnection
    case timeout
    case serverError(statusCode: Int, message: String)
    case decodingFailed(underlying: Error)
    case unauthorized
    case notFound
    
    var errorDescription: String? {
        switch self {
        case .invalidURL:
            return "잘못된 URL이에요."
        case .noConnection:
            return "인터넷 연결을 확인해주세요."
        case .timeout:
            return "요청 시간이 초과됐어요. 다시 시도해주세요."
        case .serverError(let code, let message):
            return "서버 오류 (\(code)): \(message)"
        case .decodingFailed(let error):
            return "데이터 파싱 실패: \(error.localizedDescription)"
        case .unauthorized:
            return "로그인이 필요해요."
        case .notFound:
            return "요청한 데이터를 찾을 수 없어요."
        }
    }
    
    // 재시도 가능 여부
    var isRetryable: Bool {
        switch self {
        case .timeout, .noConnection, .serverError(500..., _):
            return true
        default:
            return false
        }
    }
}

// 1. do-catch 패턴
func loadProfile() async {
    do {
        let user = try await userRepository.fetchUser(id: currentUserId)
        updateUI(with: user)
    } catch NetworkError.unauthorized {
        navigateToLogin()
    } catch NetworkError.noConnection {
        showOfflineMessage()
    } catch let networkError as NetworkError {
        showError(networkError.errorDescription ?? "알 수 없는 오류")
    } catch {
        showError("예상치 못한 오류: \(error.localizedDescription)")
    }
}

// 2. Result 타입으로 에러 전파 방지
func safeFetchUser(id: String) async -> Result<User, NetworkError> {
    do {
        let user = try await userRepository.fetchUser(id: id)
        return .success(user)
    } catch let error as NetworkError {
        return .failure(error)
    } catch {
        return .failure(.serverError(statusCode: 0, message: error.localizedDescription))
    }
}

// 사용
let result = await safeFetchUser(id: "123")
switch result {
case .success(let user):
    print("사용자: \(user.name)")
case .failure(let error):
    print("실패: \(error.errorDescription ?? "")")
}

// 3. TaskGroup에서 에러 처리
func loadAllData() async throws {
    try await withThrowingTaskGroup(of: Void.self) { group in
        group.addTask { try await self.loadUsers() }
        group.addTask { try await self.loadPosts() }
        group.addTask { try await self.loadSettings() }
        
        // 하나라도 실패하면 전체 취소
        try await group.waitForAll()
    }
}

// ❌ 구식 방법
DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
    self.doSomething()
}

// ✅ 현대적 방법 - Task.sleep
Task {
    try await Task.sleep(for: .seconds(2))
    await doSomething()
}

// ✅ 더 정밀한 제어
Task {
    try await Task.sleep(until: .now + .seconds(2), clock: .continuous)
    await doSomething()
}

// ⚠️ Actor 호핑(Actor Hopping) 주의
actor DataProcessor {
    func processItems(_ items: [Item]) async -> [Result] {
        var results: [Result] = []
        
        for item in items {
            // ❌ 매 반복마다 다른 Actor로 hop - 성능 저하
            let result = await otherActor.process(item)
            results.append(result)
        }
        
        return results
    }
    
    func processItemsOptimized(_ items: [Item]) async -> [Result] {
        // ✅ 한 번에 모든 아이템 전달 - Actor hop 최소화
        return await otherActor.processAll(items)
    }
}

// ✅ 배치 처리로 Actor hop 최소화
actor BatchProcessor {
    func processAll(_ items: [Item]) async -> [Result] {
        // 내부에서 처리 - hop 없음
        return items.map { process($0) }
    }
    
    private func process(_ item: Item) -> Result {
        // 동기 처리
        return Result(item)
    }
}

class ViewController: UIViewController {
    private var loadTask: Task<Void, Never>?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        startLoading()
    }
    
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        // 화면 사라질 때 Task 취소 - 메모리 누수 방지!
        loadTask?.cancel()
    }
    
    func startLoading() {
        loadTask = Task { [weak self] in
            guard let self = self else { return }
            
            do {
                let data = try await self.fetchData()
                
                // Task가 취소됐는지 확인
                guard !Task.isCancelled else { return }
                
                await MainActor.run { [weak self] in
                    self?.updateUI(with: data)
                }
            } catch {
                print("에러: \(error)")
            }
        }
    }
}

// ✅ Task 내부에서 self 캡처 주의
// - Task는 강한 참조를 만들 수 있어
// - [weak self] 캡처 리스트 사용 권장
// - 또는 Task를 저장하고 적절히 취소

// Task.detached - 부모 Task의 우선순위, Actor 컨텍스트 상속 안 함
func processHeavyData() {
    // 현재 @MainActor 컨텍스트에서 완전히 분리
    Task.detached(priority: .background) {
        // 이 코드는 메인 스레드와 무관하게 실행
        let result = await heavyComputation()
        
        // UI 업데이트는 명시적으로 메인 스레드로
        await MainActor.run {
            self.updateUI(with: result)
        }
    }
}

// 일반 Task vs Task.detached 차이
@MainActor
class ViewModel {
    func doWork() {
        // 일반 Task: @MainActor 컨텍스트 상속 (메인 스레드에서 시작)
        Task {
            // 여기도 메인 스레드에서 시작!
            await someWork()
        }
        
        // Task.detached: 컨텍스트 상속 없음
        Task.detached {
            // 메인 스레드와 무관한 스레드에서 실행
            await someWork()
        }
    }
}

지금까지 배운 내용을 한 번에 정리해보자. 어떤 상황에서 어떤 도구를 써야 하는지 명확하게 알아두면 실전에서 바로 써먹을 수 있어!

기존 프로젝트에 Swift Concurrency를 도입할 때 어떻게 해야 할지 단계별로 알아보자. 한 번에 다 바꾸려고 하면 망해. 점진적으로 가야 해! 😅

// 마이그레이션 예시: NotificationCenter → AsyncStream
extension NotificationCenter {
    func notifications(
        named name: Notification.Name,
        object: AnyObject? = nil
    ) -> AsyncStream<Notification> {
        return AsyncStream { continuation in
            let observer = self.addObserver(
                forName: name,
                object: object,
                queue: nil
            ) { notification in
                continuation.yield(notification)
            }
            
            continuation.onTermination = { _ in
                self.removeObserver(observer)
            }
        }
    }
}

// 사용
func observeKeyboardChanges() async {
    for await notification in NotificationCenter.default.notifications(
        named: UIResponder.keyboardWillShowNotification
    ) {
        handleKeyboardShow(notification)
    }
}

// XCTest에서 async 테스트
class UserServiceTests: XCTestCase {
    func testFetchUser() async throws {
        let service = UserService()
        let user = try await service.fetchUser(id: "test123")
        
        XCTAssertEqual(user.id, "test123")
        XCTAssertFalse(user.name.isEmpty)
    }
    
    func testFetchUserFails() async throws {
        let service = UserService()
        
        do {
            _ = try await service.fetchUser(id: "invalid")
            XCTFail("에러가 발생해야 해!")
        } catch NetworkError.notFound {
            // 예상된 에러 - 테스트 통과
        }
    }
}

Swift Concurrency를 쓰다 보면 흔히 빠지는 함정들이 있어. 미리 알아두면 삽질을 줄일 수 있어! 🕳️

// ❌ 안티패턴: Actor 내부에서 불필요한 await
actor DataManager {
    var data: [String] = []
    
    func processData() async {
        // 이 함수 내부에서 self.data에 접근할 때 await 불필요!
        // Actor 내부에서는 자신의 상태에 동기적으로 접근 가능
        for item in data {  // ✅ await 없이 접근
            await processItem(item)  // 외부 비동기 함수 호출 시만 await
        }
    }
}

// ✅ 올바른 패턴
actor DataManager {
    var data: [String] = []
    
    func processData() async {
        let snapshot = data  // 현재 상태 스냅샷 (동기)
        
        for item in snapshot {
            await processItem(item)  // 외부 호출만 await
        }
    }
}

// ❌ 안티패턴: Task를 저장하지 않으면 취소 불가
class ViewController: UIViewController {
    func viewDidLoad() {
        super.viewDidLoad()
        
        // 이 Task는 취소할 방법이 없어!
        Task {
            await loadData()
        }
    }
}

// ✅ 올바른 패턴: Task 저장 및 취소
class ViewController: UIViewController {
    private var loadingTask: Task<Void, Never>?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        loadingTask = Task {
            await loadData()
        }
    }
    
    override func viewDidDisappear(_ animated: Bool) {
        super.viewDidDisappear(animated)
        loadingTask?.cancel()
    }
}

// ❌ 절대 하면 안 되는 패턴!
func synchronousFunction() {
    // 이렇게 하면 데드락 발생 가능!
    let result = try! await asyncFunction()  // 컴파일 에러
    
    // RunLoop 블로킹도 위험해
    let semaphore = DispatchSemaphore(value: 0)
    Task {
        result = await asyncFunction()
        semaphore.signal()
    }
    semaphore.wait()  // 메인 스레드 블로킹 → 데드락!
}

// ✅ 올바른 방법: Task로 감싸기
func synchronousFunction() {
    Task {
        let result = await asyncFunction()
        await MainActor.run {
            updateUI(with: result)
        }
    }
}

// ⚠️ Actor 재진입 주의!
actor ImageCache {
    private var cache: [URL: UIImage] = [:]
    
    // ❌ 재진입 문제 발생 가능
    func loadImage(url: URL) async throws -> UIImage {
        if let cached = cache[url] {
            return cached
        }
        
        // await 지점에서 다른 Task가 같은 URL로 진입 가능!
        let image = try await downloadImage(url: url)
        
        // 이미 다른 Task가 같은 이미지를 저장했을 수 있어
        cache[url] = image
        return image
    }
    
    // ✅ 재진입 안전한 버전
    private var loadingTasks: [URL: Task<UIImage, Error>] = [:]
    
    func loadImageSafe(url: URL) async throws -> UIImage {
        if let cached = cache[url] {
            return cached
        }
        
        // 이미 로딩 중인 Task가 있으면 재사용
        if let existingTask = loadingTasks[url] {
            return try await existingTask.value
        }
        
        let task = Task {
            try await downloadImage(url: url)
        }
        loadingTasks[url] = task
        
        do {
            let image = try await task.value
            cache[url] = image
            loadingTasks.removeValue(forKey: url)
            return image
        } catch {
            loadingTasks.removeValue(forKey: url)
            throw error
        }
    }
}

지금까지 배운 모든 걸 활용해서 간단한 재능 공유 앱의 핵심 로직을 만들어보자. 재능넷처럼 다양한 재능을 거래하는 플랫폼을 상상하면서 코드를 짜볼게! 🎨

import Foundation

// MARK: - 모델 정의
struct Talent: Codable, Sendable, Identifiable {
    let id: String
    let title: String
    let description: String
    let price: Int
    let category: TalentCategory
    let seller: User
    let rating: Double
    let reviewCount: Int
}

struct User: Codable, Sendable, Identifiable {
    let id: String
    let name: String
    let profileImageURL: URL?
    let bio: String
}

enum TalentCategory: String, Codable, Sendable {
    case design, development, marketing, music, writing
}

// MARK: - 네트워크 서비스
actor NetworkService {
    private let session: URLSession
    private let baseURL: URL
    private var requestCount = 0
    
    init(baseURL: URL) {
        self.baseURL = baseURL
        self.session = URLSession.shared
    }
    
    func get<T: Decodable>(_ path: String, as type: T.Type) async throws -> T {
        requestCount += 1
        
        guard let url = URL(string: path, relativeTo: baseURL) else {
            throw NetworkError.invalidURL
        }
        
        let (data, response) = try await session.data(from: url)
        
        guard let httpResponse = response as? HTTPURLResponse else {
            throw NetworkError.serverError(statusCode: 0, message: "Invalid response")
        }
        
        switch httpResponse.statusCode {
        case 200...299:
            return try JSONDecoder().decode(T.self, from: data)
        case 401:
            throw NetworkError.unauthorized
        case 404:
            throw NetworkError.notFound
        default:
            throw NetworkError.serverError(
                statusCode: httpResponse.statusCode,
                message: "Server error"
            )
        }
    }
    
    func getRequestCount() -> Int {
        return requestCount
    }
}

// MARK: - 재능 Repository
actor TalentRepository {
    private let networkService: NetworkService
    private var cache: [String: Talent] = [:]
    private var listCache: [String: [Talent]] = [:]
    
    init(networkService: NetworkService) {
        self.networkService = networkService
    }
    
    func fetchTalents(category: TalentCategory? = nil) async throws -> [Talent] {
        let cacheKey = category?.rawValue ?? "all"
        
        if let cached = listCache[cacheKey] {
            return cached
        }
        
        let path = category.map { "/talents?category=\($0.rawValue)" } ?? "/talents"
        let talents = try await networkService.get(path, as: [Talent].self)
        
        listCache[cacheKey] = talents
        talents.forEach { cache[$0.id] = $0 }
        
        return talents
    }
    
    func fetchTalent(id: String) async throws -> Talent {
        if let cached = cache[id] {
            return cached
        }
        
        let talent = try await networkService.get("/talents/\(id)", as: Talent.self)
        cache[id] = talent
        return talent
    }
    
    func searchTalents(query: String) async throws -> [Talent] {
        let encoded = query.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? query
        return try await networkService.get("/talents/search?q=\(encoded)", as: [Talent].self)
    }
    
    func clearCache() {
        cache.removeAll()
        listCache.removeAll()
    }
}

// MARK: - ViewModel
@MainActor
class TalentMarketViewModel: ObservableObject {
    @Published var featuredTalents: [Talent] = []
    @Published var recentTalents: [Talent] = []
    @Published var searchResults: [Talent] = []
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private let repository: TalentRepository
    private var searchTask: Task<Void, Never>?
    private var loadTask: Task<Void, Never>?
    
    init(repository: TalentRepository) {
        self.repository = repository
    }
    
    // 홈 화면 데이터 로드 - 병렬 처리!
    func loadHomeData() {
        loadTask?.cancel()
        
        loadTask = Task {
            isLoading = true
            errorMessage = nil
            
            do {
                // 두 카테고리를 동시에 로드!
                async let featured = repository.fetchTalents(category: .design)
                async let recent = repository.fetchTalents(category: .development)
                
                let (f, r) = try await (featured, recent)
                
                guard !Task.isCancelled else { return }
                
                featuredTalents = f
                recentTalents = r
                
            } catch is CancellationError {
                // 취소 - 무시
            } catch {
                errorMessage = "데이터를 불러오는데 실패했어요 😢"
                print("에러: \(error)")
            }
            
            isLoading = false
        }
    }
    
    // 검색 - 디바운싱 적용
    func search(query: String) {
        searchTask?.cancel()
        
        guard !query.isEmpty else {
            searchResults = []
            return
        }
        
        searchTask = Task {
            // 0.4초 디바운싱
            try? await Task.sleep(for: .milliseconds(400))
            guard !Task.isCancelled else { return }
            
            do {
                searchResults = try await repository.searchTalents(query: query)
            } catch is CancellationError {
                // 취소 - 무시
            } catch {
                errorMessage = "검색 중 오류가 발생했어요"
            }
        }
    }
    
    // 여러 카테고리 동시 로드
    func loadAllCategories() async throws -> [TalentCategory: [Talent]] {
        return try await withThrowingTaskGroup(of: (TalentCategory, [Talent]).self) { group in
            for category in TalentCategory.allCases {
                group.addTask {
                    let talents = try await self.repository.fetchTalents(category: category)
                    return (category, talents)
                }
            }
            
            var result: [TalentCategory: [Talent]] = [:]
            for try await (category, talents) in group {
                result[category] = talents
            }
            return result
        }
    }
    
    deinit {
        loadTask?.cancel()
        searchTask?.cancel()
    }
}

Xcode의 Instruments에는 Swift Concurrency 전용 도구들이 있어:

// Thread Sanitizer 활성화 방법
// Xcode → Product → Scheme → Edit Scheme → Run → Diagnostics
// → Thread Sanitizer 체크

// 런타임 데이터 레이스 감지 예시
// Thread Sanitizer가 이런 코드를 잡아줘:
class UnsafeCounter {
    var count = 0  // ⚠️ 여러 스레드에서 동시 접근 시 데이터 레이스!
    
    func increment() {
        count += 1  // Thread Sanitizer가 경고!
    }
}

// ✅ Actor로 수정
actor SafeCounter {
    var count = 0
    
    func increment() {
        count += 1  // 안전!
    }
}

import OSLog

// 구조화된 로깅
let logger = Logger(subsystem: "com.myapp", category: "networking")

func fetchData() async throws -> Data {
    logger.info("데이터 페치 시작")
    
    let startTime = Date()
    
    do {
        let data = try await networkService.getData()
        let elapsed = Date().timeIntervalSince(startTime)
        logger.info("데이터 페치 완료: \(elapsed, format: .fixed(precision: 3))초")
        return data
    } catch {
        logger.error("데이터 페치 실패: \(error.localizedDescription)")
        throw error
    }
}

// Task ID로 추적
func trackedTask() async {
    let taskID = UUID().uuidString.prefix(8)
    logger.debug("Task \(taskID) 시작")
    
    await doWork()
    
    logger.debug("Task \(taskID) 완료")
}

와, 진짜 많이 배웠다! 처음에 콜백 지옥 얘기로 시작해서 여기까지 왔네. 오늘 배운 핵심 내용들을 한 번 더 정리해볼게:

Swift Concurrency는 계속 발전하고 있어. Swift 6에서는 더 엄격한 동시성 검사가 기본으로 활성화될 예정이야. 지금부터 올바른 패턴을 익혀두면 미래에도 걱정 없어! 🚀

프로그래밍 실력을 키우고 싶다면 이런 기술적인 내용들을 꾸준히 공부하는 게 중요해. 혹시 Swift 개발 관련 도움이 필요하다면 재능넷에서 실력 있는 iOS 개발자들의 도움을 받아볼 수도 있어. 다양한 재능을 가진 개발자들이 모여있거든! 😊