Swift 공식 문서 정리 - 동시성 (Concurrency)

안녕하세요. 오늘은 Swift의 동시성에 대해 알아보겠습니다. 동시성은 Swift 5.5에서 도입된 중요한 기능으로, 비동기 코드를 더 안전하고 직관적으로 작성할 수 있게 해줍니다. 복잡한 개념이지만 함께 차근차근 살펴보도록 하겠습니다!

📌 동시성이란? (Understanding Concurrency)

Swift에서 동시성은 크게 두 가지 개념을 포함합니다:

• 비동기(Asynchronous) 코드: 실행 중에 일시 중단되었다가 나중에 다시 재개될 수 있는 코드입니다. 한 번에 프로그램의 한 부분만 실행됩니다.
• 병렬(Parallel) 코드: 여러 작업이 동시에 실행될 수 있는 코드입니다. 예를 들어, 4코어 프로세서는 4개의 작업을 동시에 실행할 수 있습니다.

동시성의 이점: 네트워크 요청, 파일 처리와 같은 시간이 오래 걸리는 작업을 수행하는 동안에도 UI를 응답성 있게 유지할 수 있습니다.

Swift의 동시성 모델은 쓰레드 위에 구축되어 있지만, 직접 쓰레드를 관리할 필요가 없습니다. 시스템이 비동기 함수의 실행을 자동으로 관리해줍니다.

📌 비동기 함수 정의하고 호출하기 (Async Functions)

비동기 함수 정의하기

async 키워드를 사용하여 비동기 함수를 정의합니다:

func listPhotos(inGallery name: String) async -> [String] {
    // 비동기 네트워킹 코드
    return ["IMG001", "IMG99", "IMG0404"]
}

함수가 비동기적이면서 에러를 던질 수도 있다면 async throws를 사용합니다:

func fetchUserData(userID: String) async throws -> UserData {
    // 네트워크 요청 중 에러가 발생할 수 있음
}

중요: async는 반환 화살표(->) 앞에 위치하고, throws가 있다면 throws 앞에 async를 작성합니다.

비동기 함수 호출하기

비동기 함수를 호출할 때는 await 키워드를 사용하여 잠재적인 중단 지점을 표시합니다:

let photoNames = await listPhotos(inGallery: "Summer Vacation")
let sortedNames = photoNames.sorted()
let name = sortedNames[0]
let photo = await downloadPhoto(named: name)
show(photo)

이 코드의 실행 흐름은 다음과 같습니다:

1. listPhotos 함수 호출 시 await에서 일시 중단될 수 있음
2. 함수가 반환되면 sortedNames와 name을 계산 (일시 중단 없음)
3. downloadPhoto 호출 시 다시 await에서 일시 중단될 수 있음
4. 최종적으로 show(photo) 실행

중단 지점(Suspension Points): await는 코드가 일시 중단될 수 있는 지점을 명시적으로 표시합니다. 이런 명시적 표시 덕분에 비동기 코드의 흐름을 더 쉽게 이해할 수 있습니다.

비동기 함수는 다음 위치에서만 호출할 수 있습니다:

• 다른 비동기 함수, 메서드, 프로퍼티 내부
• @main 타입의 static main() 메서드 내부
• 구조화되지 않은 동시성 작업 내부

📌 비동기 시퀀스 (Asynchronous Sequences)

컬렉션의 요소를 비동기적으로 하나씩 처리해야 할 때는 비동기 시퀀스를 사용합니다:

import Foundation

let handle = FileHandle.standardInput
for try await line in handle.bytes.lines {
    print(line)
}

for-await-in 루프: 일반 for-in 루프와 비슷하지만, 각 반복에서 다음 요소를 사용할 수 있을 때까지 기다릴 수 있습니다.

자신만의 비동기 시퀀스를 만들려면 AsyncSequence 프로토콜을 구현하면 됩니다.

📌 병렬로 비동기 함수 호출하기 (Parallel Async Calls)

여러 비동기 작업을 순차적으로 실행하면 각 작업은 이전 작업이 완료될 때까지 기다립니다:

// 순차적 실행 - 각 다운로드가 이전 다운로드 완료 후 시작
let firstPhoto = await downloadPhoto(named: photoNames[0])
let secondPhoto = await downloadPhoto(named: photoNames[1])
let thirdPhoto = await downloadPhoto(named: photoNames[2])

작업들을 병렬로 실행하려면 async let을 사용합니다:

// 병렬 실행 - 모든 다운로드가 동시에 시작
async let firstPhoto = downloadPhoto(named: photoNames[0])
async let secondPhoto = downloadPhoto(named: photoNames[1])
async let thirdPhoto = downloadPhoto(named: photoNames[2])

// 모든 결과가 필요할 때 await
let photos = await [firstPhoto, secondPhoto, thirdPhoto]
show(photos)

순차적 vs 병렬:

• 다음 코드가 이전 함수의 결과에 의존한다면 일반 await를 사용하세요.
• 여러 독립적인 작업을 동시에 실행하려면 async let을 사용하세요.

📌 작업과 작업 그룹 (Tasks and Task Groups)

Swift 동시성의 핵심 단위는 작업(Task)입니다. 작업은 비동기적으로 실행할 수 있는 작업 단위입니다.

작업 그룹으로 여러 작업 관리하기

여러 작업을 동적으로 생성하고 관리하려면 작업 그룹(Task Group)을 사용합니다:

await withTaskGroup(of: Data.self) { group in
    let photoNames = await listPhotos(inGallery: "Summer Vacation")
    
    for name in photoNames {
        group.addTask {
            return await downloadPhoto(named: name)
        }
    }

    for await photo in group {
        show(photo)
    }
}

작업 그룹에서 결과를 수집하고 반환하려면:

let photos = await withTaskGroup(of: Data.self) { group in
    let photoNames = await listPhotos(inGallery: "Summer Vacation")
    
    for name in photoNames {
        group.addTask {
            return await downloadPhoto(named: name)
        }
    }

    var results: [Data] = []
    for await photo in group {
        results.append(photo)
    }
    
    return results
}

구조적 동시성(Structured Concurrency): 작업들 사이에 명시적인 부모-자식 관계가 있어 작업 관리와 취소가 더 쉬워집니다.

작업 취소 (Task Cancellation)

Swift는 협력적 취소 모델(cooperative cancellation)을 사용합니다. 작업이 취소되었는지 확인하는 방법은 두 가지입니다:

1. Task.checkCancellation()을 호출하여 취소 시 에러를 발생시킴
2. Task.isCancelled 프로퍼티를 확인하여 직접 취소 처리

 

let photos = await withTaskGroup(of: Optional<Data>.self) { group in
    let photoNames = await listPhotos(inGallery: "Summer Vacation")
    
    for name in photoNames {
        let added = group.addTaskUnlessCancelled {
            // 취소 여부 확인
            guard !Task.isCancelled else { return nil }
            return await downloadPhoto(named: name)
        }
        guard added else { break }
    }

    var results: [Data] = []
    for await photo in group {
        if let photo { results.append(photo) }
    }
    return results
}

협력적 취소: 작업이 취소되면 자동으로 중단되지 않습니다. 대신, 작업은 취소되었는지 확인하고 적절히 반응해야 합니다.

📌 구조화되지 않은 동시성 (Unstructured Concurrency)

때로는 현재 구조와 관계없이 작업을 실행해야 할 때가 있습니다. 이럴 때 구조화되지 않은 동시성을 사용합니다:

// 현재 액터에서 구조화되지 않은 작업 생성
let handle = Task {
    return await add(newPhoto, toGalleryNamed: "Spring Adventures")
}
let result = await handle.value

// 분리된 작업 생성 (현재 액터와 무관)
let detachedHandle = Task.detached {
    return await processPhoto(newPhoto)
}

주의: 구조화되지 않은 작업은 유연하지만, 그만큼 관리에 대한 책임도 큽니다.

📌 액터 (Actors)

액터는 동시성 코드 간에 데이터를 안전하게 공유할 수 있게 해주는 참조 타입입니다:

actor TemperatureLogger {
    let label: String
    var measurements: [Int]
    private(set) var max: Int

    init(label: String, measurement: Int) {
        self.label = label
        self.measurements = [measurement]
        self.max = measurement
    }
    
    func update(with measurement: Int) {
        measurements.append(measurement)
        if measurement > max {
            max = measurement
        }
    }
}

액터 사용 방법:

let logger = TemperatureLogger(label: "Outdoors", measurement: 25)
// 액터의 프로퍼티나 메서드에 접근할 때는 await 필요
print(await logger.max)  // 25

// 다른 측정값 추가
await logger.update(with: 30)
print(await logger.max)  // 30

액터 분리(Actor Isolation): 액터는 한 번에 하나의 작업만 변경 가능한 상태에 접근할 수 있도록 보장합니다. 이를 통해 데이터 경쟁 조건을 방지합니다.

액터 내부에서는 자신의 프로퍼티에 접근할 때 await 없이 직접 접근할 수 있습니다:

extension TemperatureLogger {
    func convertFahrenheitToCelsius() {
        // 액터 내부에서는 await 없이 프로퍼티에 접근 가능
        for i in measurements.indices {
            measurements[i] = (measurements[i] - 32) * 5 / 9
        }
    }
}

📌 전송 가능 타입 (Sendable Types)

동시성 도메인 간에 데이터를 안전하게 전달하려면 해당 타입이 '전송 가능(Sendable)'해야 합니다:

// 전송 가능 타입 선언
struct TemperatureReading: Sendable {
    var measurement: Int
}

// 액터 메서드에 전송 가능한 타입 전달
extension TemperatureLogger {
    func addReading(from reading: TemperatureReading) {
        measurements.append(reading.measurement)
    }
}

let logger = TemperatureLogger(label: "Tea kettle", measurement: 85)
let reading = TemperatureReading(measurement: 45)
await logger.addReading(from: reading)

다음과 같은 타입은 자동으로 전송 가능합니다:

• 전송 가능한 프로퍼티만 가진 구조체
• 전송 가능한 연관값만 가진 열거형
• 변경 불가능한 클래스(읽기 전용 프로퍼티만 가진)

타입을 명시적으로 전송 불가능하게 표시할 수도 있습니다:

struct FileDescriptor {
    let rawValue: CInt
}

// 이 타입을 전송 불가능하게 표시
@available(*, unavailable)
extension FileDescriptor: Sendable { }

📌 정리

Swift의 동시성 시스템은 복잡한 비동기 코드를 안전하고 이해하기 쉽게 작성할 수 있도록 도와줍니다. 주요 개념을 요약해보면:

1. 비동기 함수(async/await): 코드 실행을 일시 중단하고 나중에 재개할 수 있음
2. 병렬 실행(async let): 여러 비동기 작업을 동시에 시작하고 모든 결과가 필요할 때 기다림
3. 작업과 작업 그룹: 동시성 코드의 단위와 구조화된 관리 방법
4. 액터: 데이터 레이스 없이 상태를 안전하게 공유하는 방법
5. 전송 가능 타입: 동시성 경계를 넘어 안전하게 전달될 수 있는 데이터 타입

Swift의 동시성 모델은 특히 다음과 같은 이점이 있습니다:

• 코드가 더 읽기 쉽고 유지보수하기 쉬움
• 컴파일 시간에 더 많은 오류를 잡을 수 있음
• 데이터 레이스와 같은 동시성 버그를 방지하는 데 도움됨
• 쓰레드 관리를 직접 할 필요가 없음