Swift Concurrency: async/await 완전정복 🚀

안녕하세요 여러분! 오늘은 Swift Concurrency의 핵심인 async/await에 대해 알아볼게요~ 😊

왜 async/await가 필요한 거임? 🤔

기존에 우리가 비동기 작업을 할 때는 completion handler를 사용했잖아요. 근데 이거 진짜 지옥이었음ㅋㅋ 콜백 지옥이라고도 하죠. 코드가 이렇게 됨:

func fetchUserData(completion: @escaping (User?) -> Void) {
    fetchUserID { id in
        fetchUserProfile(id: id) { profile in
            fetchUserPosts(profile: profile) { posts in
                let user = User(id: id, profile: profile, posts: posts)
                completion(user)
            }
        }
    }
}

이런 코드 보면 진짜 현기증 나지 않음? 들여쓰기만 봐도 현타 오잖아ㅋㅋ

async/await 등장! 구원자! 😇

Swift 5.5에서 드디어 async/await가 등장했어요. 이제 위의 코드를 이렇게 쓸 수 있음:

func fetchUserData() async throws -> User {
    let id = try await fetchUserID()
    let profile = try await fetchUserProfile(id: id)
    let posts = try await fetchUserPosts(profile: profile)
    return User(id: id, profile: profile, posts: posts)
}

어때요? 진짜 깔끔하지 않음? ㅋㅋ 이제 코드가 위에서 아래로 순차적으로 읽히고, 에러 처리도 try-catch로 할 수 있어서 훨씬 명확해짐!

async 함수 만드는 법 📝

async 함수는 이렇게 만들어요:

func downloadImage(url: URL) async throws -> UIImage {
    // 비동기 코드
    let (data, _) = try await URLSession.shared.data(from: url)
    guard let image = UIImage(data: data) else {
        throw ImageError.invalidData
    }
    return image
}

여기서 중요한 것:

1. 함수 선언에 async 키워드 추가
2. 비동기 작업 앞에 await 키워드 사용
3. 에러 던질 수 있으면 throws 키워드 추가

SwiftUI에서 async/await 사용하기 😎

이제 SwiftUI에서 어떻게 쓰는지 알아볼까요? iOS 17부터는 @Observable을 쓸 수 있어서 더 깔끔해졌어요!

@Observable
class ImageLoader {
    var image: UIImage?
    var isLoading = false
    var errorMessage: String?
    
    func loadImage(from url: URL) {
        isLoading = true
        errorMessage = nil
        
        Task {
            do {
                let downloadedImage = try await downloadImage(url: url)
                await MainActor.run {
                    self.image = downloadedImage
                    self.isLoading = false
                }
            } catch {
                await MainActor.run {
                    self.errorMessage = "이미지 로딩 실패ㅠㅠ: \(error.localizedDescription)"
                    self.isLoading = false
                }
            }
        }
    }
    
    private func downloadImage(url: URL) async throws -> UIImage {
        let (data, _) = try await URLSession.shared.data(from: url)
        guard let image = UIImage(data: data) else {
            throw URLError(.badServerResponse)
        }
        return image
    }
}

이걸 SwiftUI 뷰에서 사용하면:

struct ImageViewer: View {
    let imageLoader = ImageLoader()
    let imageURL = URL(string: "https://example.com/image.jpg")!
    
    var body: some View {
        VStack {
            if imageLoader.isLoading {
                ProgressView()
                    .progressViewStyle(.circular)
            } else if let image = imageLoader.image {
                Image(uiImage: image)
                    .resizable()
                    .aspectRatio(contentMode: .fit)
            } else if let errorMessage = imageLoader.errorMessage {
                Text("에러났음ㅋㅋ: \(errorMessage)")
                    .foregroundColor(.red)
            }
            
            Button("이미지 다운로드") {
                imageLoader.loadImage(from: imageURL)
            }
            .buttonStyle(.borderedProminent)
            .padding()
        }
        .padding()
        .onAppear {
            imageLoader.loadImage(from: imageURL)
        }
    }
}

왜 MainActor가 필요한 거임? 🧐

UI 업데이트는 반드시 메인 스레드에서 해야 함! 그래서 MainActor.run을 사용했어요. 아니면 클래스 전체를 MainActor로 지정할 수도 있음:

@Observable @MainActor
class ImageLoader {
    // 이제 모든 프로퍼티 업데이트가 메인 스레드에서 자동으로 실행됨!
    // ...
}

Swift Concurrency의 꿀팁들 🍯

1. Task 사용하기

Task는 비동기 작업을 시작하는 방법임. SwiftUI에서 이벤트에 반응해서 비동기 작업을 시작할 때 많이 씀:

Button("데이터 가져오기") {
    Task {
        do {
            let result = try await fetchData()
            // UI 업데이트
        } catch {
            // 에러 처리
        }
    }
}

2. Task 취소하기

작업을 취소해야 할 때:

var loadingTask: Task<Void, Never>?

func startLoading() {
    // 기존 작업 취소
    loadingTask?.cancel()
    
    // 새 작업 시작
    loadingTask = Task {
        do {
            // 주기적으로 취소됐는지 확인
            try Task.checkCancellation()
            
            let result = try await longRunningTask()
            // 결과 처리
        } catch {
            // 에러 처리
        }
    }
}

func stopLoading() {
    loadingTask?.cancel()
    loadingTask = nil
}

3. withTaskGroup으로 여러 작업 동시에 실행하기

여러 이미지를 동시에 다운로드하고 싶다면:

func loadGalleryImages(urls: [URL]) async throws -> [UIImage] {
    try await withThrowingTaskGroup(of: (Int, UIImage).self) { group in
        for (index, url) in urls.enumerated() {
            group.addTask {
                let image = try await self.downloadImage(url: url)
                return (index, image)
            }
        }
        
        var images = [UIImage?](repeating: nil, count: urls.count)
        for try await (index, image) in group {
            images[index] = image
        }
        
        return images.compactMap { $0 }
    }
}

실전 예제: SwiftUI에서 async 리스트 로딩 💪

import SwiftUI

// 모델 정의
struct Post: Identifiable, Decodable {
    let id: Int
    let title: String
    let body: String
    let userId: Int
}

// 데이터 로더
@Observable @MainActor
class PostsLoader {
    var posts: [Post] = []
    var isLoading = false
    var errorMessage: String?
    
    func loadPosts() async {
        guard !isLoading else { return }
        
        isLoading = true
        errorMessage = nil
        
        do {
            let downloadedPosts = try await fetchPosts()
            self.posts = downloadedPosts
        } catch {
            self.errorMessage = "게시물 로딩 실패: \(error.localizedDescription)"
        }
        
        isLoading = false
    }
    
    private func fetchPosts() async throws -> [Post] {
        // 네트워크 요청이 오래 걸리는 것 시뮬레이션
        try await Task.sleep(for: .seconds(1))
        
        guard let url = URL(string: "https://jsonplaceholder.typicode.com/posts") else {
            throw URLError(.badURL)
        }
        
        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([Post].self, from: data)
    }
    
    func refreshPosts() async {
        posts = []
        await loadPosts()
    }
}

// 게시물 상세 뷰
struct PostDetailView: View {
    let post: Post
    
    var body: some View {
        ScrollView {
            VStack(alignment: .leading, spacing: 16) {
                Text(post.title)
                    .font(.title)
                    .fontWeight(.bold)
                
                Text("작성자 ID: \(post.userId)")
                    .font(.subheadline)
                    .foregroundColor(.secondary)
                
                Divider()
                
                Text(post.body)
                    .font(.body)
                    .lineSpacing(6)
            }
            .padding()
        }
        .navigationTitle("게시물 상세")
    }
}

// 메인 리스트 뷰
struct PostsListView: View {
    @State private var postsLoader = PostsLoader()
    
    var body: some View {
        NavigationStack {
            ZStack {
                // 리스트 내용
                if postsLoader.isLoading && postsLoader.posts.isEmpty {
                    ProgressView("불러오는 중...")
                        .progressViewStyle(.circular)
                } else if let errorMessage = postsLoader.errorMessage {
                    VStack(spacing: 16) {
                        Image(systemName: "exclamationmark.triangle")
                            .font(.largeTitle)
                            .foregroundColor(.red)
                        Text("앗! 에러났어요 ㅠㅠ")
                            .font(.headline)
                        Text(errorMessage)
                            .font(.body)
                            .multilineTextAlignment(.center)
                        Button("다시 시도") {
                            postsLoader.loadPosts()
                        }
                        .buttonStyle(.borderedProminent)
                    }
                    .padding()
                } else {
                    postsList
                }
            }
            .navigationTitle("게시물 목록")
            .toolbar {
                ToolbarItem(placement: .topBarTrailing) {
                    Button {
                        postsLoader.refreshPosts()
                    } label: {
                        Label("새로고침", systemImage: "arrow.clockwise")
                    }
                    .disabled(postsLoader.isLoading)
                }
            }
            .task {
                if postsLoader.posts.isEmpty {
                    postsLoader.loadPosts()
                }
            }
        }
    }
    
    private var postsList: some View {
        List {
            ForEach(postsLoader.posts) { post in
                NavigationLink(destination: PostDetailView(post: post)) {
                    VStack(alignment: .leading, spacing: 8) {
                        Text(post.title)
                            .font(.headline)
                            .lineLimit(1)
                        Text(post.body)
                            .font(.subheadline)
                            .foregroundColor(.secondary)
                            .lineLimit(2)
                    }
                    .padding(.vertical, 4)
                }
            }
            
            if postsLoader.isLoading {
                HStack {
                    Spacer()
                    ProgressView()
                    Spacer()
                }
                .padding()
            }
        }
        .listStyle(.inset)
        .refreshable {
            await postsLoader.refreshPosts()
        }
    }
}

// 앱 진입점
@main
struct ConcurrencyDemoApp: App {
    var body: some Scene {
        WindowGroup {
            PostsListView()
        }
    }
}

위 코드를 보면 SwiftUI에서 async/await를 어떻게 활용하는지 완전 잘 볼 수 있어요! 중요한 포인트들을 정리해 볼게요:

1. @Observable 사용 - iOS 17에서 새로 추가된 매크로로, 상태 변화를 SwiftUI에 자동으로 알려줌
2. Task로 비동기 작업 시작
3. MainActor로 UI 업데이트
4. 에러 처리
5. .refreshable과 연동

주의해야 할 점들 ⚠️

1. 메모리 누수 조심! - Task가 완료되기 전에 뷰가 사라지면 메모리 누수가 발생할 수 있음. .task 모디파이어나 onDisappear에서 취소 처리를 꼭 해주세요.

.task {
    // .task는 뷰가 사라지면 자동으로 취소됨
    try? await loadData()
}

1. 데드락 주의! - await 호출 시 현재 실행 컨텍스트가 일시 중단되는데, 이때 다른 작업이 이 컨텍스트를 기다리고 있으면 데드락 발생 가능.
2. UI 업데이트는 MainActor에서! - 이거 진짜 중요함! UI 관련 업데이트는 반드시 메인 스레드에서 해야 함.

마지막 꿀팁: async let 바인딩 🍯

여러 비동기 작업을 동시에 실행하고 싶을 때:

async func loadDashboard() throws -> Dashboard {
    async let users = fetchUsers()
    async let posts = fetchPosts()
    async let notifications = fetchNotifications()
    
    return try await Dashboard(
        users: users,
        posts: posts,
        notifications: notifications
    )
}

이렇게 하면 세 개의 네트워크 요청이 병렬로 실행되고, 모두 완료되면 Dashboard 객체를 만들어서 반환함!

마무리 🎉

Swift Concurrency는 진짜 정말 멋진 기능이에요! async/await를 사용하면 비동기 코드가 동기 코드처럼 읽히고 이해하기 쉬워짐. SwiftUI와 조합하면 더 강력해지고요.

여러분도 이제 콜백 지옥에서 벗어나서 깔끔한 async/await의 세계로 오세요~~ 😊

다음에는 Swift Concurrency의 다른 기능인 Actor에 대해 알아볼게요! 여러분의 코딩 라이프가 더 즐거워지길 바랄게요 🙌