[Swift Concurrency] Task를 kill하면 어떻게 되나?

참고한 Medium 글 🔽

https://medium.com/@avula.koti.realpage/the-ios-interview-that-started-with-what-happens-if-you-kill-this-task-bcae4f6dfa67

 

Swift Concurrency에서 Task 취소(Cancelation)가 동작하는 방식 정리

 

Swift Concurrency의 Task.cancel()은 많은 개발자들이 오해하고 있는 부분 중 하나입니다.

아래 내용은 Swift에서 Task 취소가 실제로 어떻게 동작하는지,

그리고 취소가 전파되는 기준을 정리한 것입니다.

 

---

 

1. Task.cancel()은 Task를 “죽이는(kill)” 것이 아닙니다

 

Swift에서 Task는 즉시 종료되지 않습니다.

취소는 다음과 같은 특징을 가집니다:

 

• Task는 취소되면 즉시 종료되지 않고,
• “취소됨(canceled) 상태로 표시”만 됩니다.
• Task 내부에서 취소 여부를 확인하거나(Task.isCancelled)
• 취소 가능한 await 지점을 만나기 전까지는 계속 실행됩니다.

예시

let task = Task {
    print("Start")
    try await Task.sleep(nanoseconds: 2_000_000_000)
    print("End")
}
task.cancel()

위 코드에서 취소해도 "Start"는 출력되며,

잠자기(sleep) 중에 CancellationError가 발생해야 Task가 종료됩니다.

 

 

2. 취소는 자동으로 코드 전체에 전파되지 않습니다

 

아래와 같은 오해가 흔합니다:

 

“Task를 취소하면 내부에서 호출하는 함수도 모두 자동으로 취소된다?”

 

→ 그렇지 않습니다.

 

doSomething() 같은 함수가 취소 여부를 체크하지 않거나

취소 가능한 await를 호출하지 않으면,

Task는 취소 후에도 끝까지 실행될 수 있습니다.

 

 

예

func doSomething() async {
    // 취소 체크 없음
    // 취소 가능한 await 없음
}

이 경우 task.cancel()을 호출해도 작업은 계속 수행됩니다.

 

 

3. “취소 전파(Cancelation Propagation)”는 Task 생성 방식에 따라 다릅니다

 

Swift에서 Task는 생성 방식에 따라 부모의 취소 상태를 상속받기도 하고, 받지 않기도 합니다.

 

 

정리

Task 생성 방식취소 전파 여부

Task { }	❌ 전파 안 됨 (독립적인 top-level task)
Task.detached	❌ 전파 안 됨
async let	✅ 전파됨
TaskGroup	✅ 전파됨

예시

let parentTask = Task {
    let child = Task {
        await doSomethingSlow()
    }
    return await child.value
}

parentTask.cancel()

위 코드에서 child는 취소되지 않습니다.

Task { }는 부모-자식 관계를 만들지 않기 때문입니다.

 

 

4. Swift는 취소 시 자동 정리(cleanup)를 해주지 않습니다

 

취소는 단순히 CancellationError를 던지는 동작이며,

아래와 같은 작업을 자동으로 되돌리거나 복구하지 않습니다.

 

• 파일 쓰기 중단 및 롤백
• 네트워크 업로드 중단 후 정리
• DB 트랜잭션 복구
• 캐시 정리

 

정리는 개발자가 직접 구현해야 합니다.

 

 

예시

let task = Task {
    do {
        try await doExpensiveWork()
    } catch is CancellationError {
        await cleanUp()
    }
}
task.cancel()

 

5. 취소가 흐르도록 하려면 불필요한 Task { } 래핑을 피해야 합니다

 

아래 함수는 내부에서 독립적인 top-level task를 생성합니다:

func fetchUserData() async throws -> User {
    let task = Task {
        await refreshAuthToken()
        return try await networkService.loadUser()
    }
    return try await task.value
}

→ 이 경우, 상위 호출자가 취소되어도 내부 Task는 그대로 실행됩니다.

 

 

해결법: Task를 쓰지 않고 함수 자체를 async로 유지하기

func fetchUserData() async throws -> User {
    try await refreshAuthToken()
    return try await networkService.loadUser()
}

이 방식은 자연스럽게 호출자의 취소가 전파되며,

불필요한 Task 중첩을 방지합니다.

 

 

6. 취소 전파가 확실한 패턴: async let

 

async let을 사용하면, 취소는 자동으로 자식 작업에 전파됩니다.

 

 

예시

func fetchData() async throws -> String {
    async let name = loadName()
    async let age = loadAge()
    return "\(try await name), \(try await age)"
}

→ fetchData()가 취소되면

loadName()과 loadAge()도 자동으로 취소됩니다.

 

 

7. 정리: Swift에서 Task 취소가 실제로 일어나는 방식

 

Task 취소 후 실제 종료되려면 아래 중 하나가 필요합니다:

 

1. Task 내부에서 Task.isCancelled 체크
2. 취소 가능한 await를 만나 CancellationError가 발생
3. 개발자가 수동으로 취소를 전파
4. async let 또는 TaskGroup을 통해 부모 취소가 전파됨

 

위 조건이 하나도 없다면,

Task는 취소되더라도 끝까지 실행됩니다.

 

---

 

결론

 

Swift Concurrency의 취소 로직은 단순한 기능처럼 보이지만

실제 동작은 다음을 이해해야 제대로 다룰 수 있습니다:

 

• Task는 즉시 “죽지 않는다”
• 취소는 전파되지 않을 수 있다
• cleanup은 자동으로 일어나지 않는다
• async let / TaskGroup은 올바른 취소 전파를 제공한다
• 불필요한 Task wrapping은 취소 버그를 만든다

 

Concurrency를 올바르게 다루기 위해서는 취소의 동작 원리와 전파 규칙을 정확히 이해하는 것이 필수적입니다.

 

 

---

 

++) 예시 추가

1. Task 내부에서 Task.isCancelled 체크하는 예시들

 

예시 1 — 반복 작업 중간에 취소 여부 확인

let task = Task {
    for i in 0..<10 {
        if Task.isCancelled {
            print("Canceled while iterating. Cleaning up...")
            return
        }
        print("Processing \(i)")
        try await Task.sleep(nanoseconds: 300_000_000)
    }
}
task.cancel()

 

예시 2 — 무거운 연산 중 주기적으로 취소 체크

func heavyComputation() async {
    var result = 0

    for i in 0..<100_000 {
        if Task.isCancelled {
            print("Canceled during computation")
            return
        }
        result += i
    }

    print("Finished: \(result)")
}

let task = Task {
    await heavyComputation()
}
task.cancel()

 

예시 3 — 네트워크 재시도 로직에서 취소 반영

func fetchWithRetry() async throws -> Data {
    for attempt in 1...3 {
        if Task.isCancelled {
            throw CancellationError()
        }

        do {
            return try await networkService.fetch()
        } catch {
            if attempt == 3 { throw error }
        }
    }
    throw URLError(.unknown)
}

 

 

2. 취소 가능한 await를 만나 CancellationError가 발생하는 예시들

 

Swift Concurrency에서 일부 await는 자동으로 취소를 전파합니다.

 

대표적인 예:

 

• Task.sleep
• 네트워크 API (URLSession 기반)
• Actor 접근
• async let 결과 기다리기
• TaskGroup 내 작업 기다리기 등

 

예시 1 — Task.sleep는 취소 시 바로 CancellationError 발생

let task = Task {
    print("Start")
    try await Task.sleep(nanoseconds: 5_000_000_000)
    print("End") // 실행되지 않음
}

task.cancel()

 

예시 2 — URLSession 요청에서 취소가 발생

func load() async throws -> Data {
    let url = URL(string: "https://example.com")!
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

let task = Task {
    try await load()
}

task.cancel() // URLSession이 자동으로 취소됨 → CancellationError 발생

 

예시 3 — Actor 접근 중 취소

actor Counter {
    var value = 0
    func increment() { value += 1 }
}

let counter = Counter()

let task = Task {
    try await Task.sleep(nanoseconds: 1_000_000_000)
    await counter.increment() // 이 지점에서 취소가 감지될 수 있음
}

task.cancel()

 

 

3. 개발자가 수동으로 취소를 전파하는 예시들

 

수동 전파란, 한 Task가 취소되었음을 감지하고

내부에서 다른 작업에도 취소를 전달하는 방식입니다.

 

 

예시 1 — 취소 시 cleanup + 자식 task 취소

func loadData() async throws {
    let child = Task {
        try await Task.sleep(nanoseconds: 5_000_000_000)
        print("Child finished")
    }

    do {
        try await child.value
    } catch is CancellationError {
        child.cancel()
        print("Canceled and cleaned")
        throw CancellationError()
    }
}

예시 2 — 여러 작업을 동시에 실행하고 취소 시 모두 중단

func fetchMultiple() async throws {
    let t1 = Task { try await loadA() }
    let t2 = Task { try await loadB() }

    do {
        let resultA = try await t1.value
        let resultB = try await t2.value
        print(resultA, resultB)
    } catch is CancellationError {
        t1.cancel()
        t2.cancel()
        throw CancellationError()
    }
}

예시 3 — Operation-style cleanup

let task = Task {
    do {
        try await longRunningProcess()
    } catch is CancellationError {
        await rollbackChanges()
        throw CancellationError()
    }
}
task.cancel()