TaskGroup untuk paralelisme

Mengapa TaskGroup?

Menjalankan dan mengumpulkan

func work(_ n: Int) async -> Int {
    try? await Task.sleep(nanoseconds: UInt64(50_000_000 * n)) // simulate delay
    return n * n
}

Task {
    let result = await withTaskGroup(of: Int.self) { group in
        for i in 1...4 {
            group.addTask { await work(i) }   // spawn child
        }
        var sum = 0
        for await value in group {            // values as they finish
            sum += value
        }
        return sum
    }
    print("sum =", result) // 1^2+2^2+3^2+4^2 = 30
}

Menggabungkan hasil

func sumSquares(_ n: Int) async -> Int {
    await withTaskGroup(of: Int.self) { group in
        (1...n).forEach { i in
            group.addTask { await work(i) }
        }
        return await group.reduce(0, +)   // reduce over async sequence
    }
}

Task {
    print(await sumSquares(5)) // 55
}

Grup yang melempar kesalahan

enum CalcError: Error { case boom(Int) }

func risky(_ i: Int) async throws -> Int {
    try await Task.sleep(nanoseconds: 30_000_000)
    if i == 3 { throw CalcError.boom(i) }
    return i
}

Task {
    do {
        let total = try await withThrowingTaskGroup(of: Int.self) { group in
            for i in 1...5 { group.addTask { try await risky(i) } }
            var sum = 0
            do {
                for try await v in group { sum += v }
                return sum
            } catch {
                // Cancel remaining children on error
                group.cancelAll()
                throw error
            }
        }
        print("total:", total)
    } catch {
        print("failed:", error) // boom(3)
    }
}

Membatalkan anak

func slow(_ i: Int) async -> Int {
    for _ in 0..<5 {
        if Task.isCancelled { return -1 } // observe cancellation cooperatively
        try? await Task.sleep(nanoseconds: 20_000_000)
    }
    return i * 10
}

Task {
    let value = await withTaskGroup(of: Int.self) { group in
        for i in 1...3 { group.addTask { await slow(i) } }
        // cancel quickly (e.g., user navigated away)
        group.cancelAll()
        // Still need to drain results; cancelled children should exit fast
        var out = 0
        for await v in group { out += v }
        return out
    }
    print("after cancel, collected:", value)
}

Panduan

Semantik penggabungan terstruktur

Ringkasan