TaskGroup für Parallelität
Verwenden Sie withTaskGroup , um parallele Unteraufgaben auszuführen, iterieren Sie über Ergebnisse, sobald sie eintreffen, und behandeln Sie Fehler mit der fehlerwerfenden Variante.
TaskGroup für Parallelität ist eine kostenlose Swift Academy-Lektion auf CoddyKit. Dies ist Lektion 1 von 3. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Swift Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Swift Academy-Kurs umfasst insgesamt 3 Lektionen.
Warum TaskGroup?
TaskGroup startet viele untergeordnete Tasks parallel und sammelt Ergebnisse sicher. Die Gruppe wird erst beendet, wenn alle untergeordneten Tasks abgeschlossen sind.
- Mit group.addTask starten
- Mit for await verarbeiten
- Die Variante throwing zur Weitergabe von Fehlern verwenden
Starten und sammeln
Starten Sie untergeordnete Tasks mit addTask und durchlaufen Sie die Ergebnisse mit for await, sobald sie eintreffen.
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
}Ergebnisse aggregieren
Eine Gruppe ist eine asynchrone Sequenz von Ergebnissen; verwenden Sie eine Reduktion oder eine Schleife, um einen einzelnen Rückgabewert zu erzeugen.
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
}Gruppen mit Fehlerauslösung
Verwenden Sie withThrowingTaskGroup, um den ersten Fehler weiterzugeben, und brechen Sie die übrigen untergeordneten Tasks ab, um unnötige Arbeit zu vermeiden.
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)
}
}Untergeordnete Tasks abbrechen
Rufen Sie group.cancelAll() auf, um einen Abbruch anzufordern. Untergeordnete Tasks sollten Task.isCancelled (oder Task.checkCancellation()) prüfen und sich schnell beenden.
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)
}Richtlinien
Tipps:
- Bevorzugen Sie Task-Gruppen, wenn die Anzahl der untergeordneten Tasks dynamisch ist.
- Verwenden Sie für ein sofortiges Fehlschlagen die Variante throwing.
- Leeren Sie die Gruppe nach einem Abbruch immer vollständig, indem Sie die Ergebnisse durchlaufen.
- Halten Sie untergeordnete Tasks klein, damit sie schnell auf einen Abbruch reagieren.
Semantik des strukturierten Beitritts
Kurztest: Was wird durch withTaskGroup garantiert?
Zusammenfassung
Zusammenfassung: Verwenden Sie withTaskGroup, um parallele Arbeit zu starten und die Ergebnisse beim Eintreffen zu durchlaufen. Bevorzugen Sie die Variante throwing, um bei einem Fehler sofort abzubrechen und die übrigen Tasks zu beenden.
Häufig gestellte Fragen
Ist die Lektion „TaskGroup für Parallelität“ kostenlos?
Ja — der vollständige Text von „TaskGroup für Parallelität“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Swift Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Swift Academy-Kurs umfasst insgesamt 3 Lektionen.
Was lerne ich in „TaskGroup für Parallelität“?
Verwenden Sie withTaskGroup , um parallele Unteraufgaben auszuführen, iterieren Sie über Ergebnisse, sobald sie eintreffen, und behandeln Sie Fehler mit der fehlerwerfenden Variante. Du übst Swift Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um Swift Academy zu starten?
Keine Vorkenntnisse erforderlich. Swift Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 3.
Wie lange dauert die Lektion „TaskGroup für Parallelität“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser Swift Academy-Lektion Code schreiben und ausführen?
Ja. Jede Swift Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- TaskGroup für Parallelität
- Actors und Datenisolierung, nonisolated
- Sendable und Prüfung der Thread-Sicherheit