TaskGroup pour le parallélisme
Utilisez withTaskGroup pour exécuter des tâches enfants en parallèle, parcourez les résultats à mesure de leur arrivée et gérez les échecs avec la variante qui propage les erreurs.
TaskGroup pour le parallélisme est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 3. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Swift Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Swift Academy comprend 3 leçons au total.
Pourquoi TaskGroup ?
TaskGroup lance de nombreuses tâches enfants en parallèle et collecte leurs résultats en toute sécurité. Le groupe ne se termine que lorsque tous les enfants ont terminé.
- Lancez-les avec group.addTask
- Consommez les résultats avec for await
- Utilisez la variante throwing pour propager les erreurs
Lancer et collecter
Lancez les enfants avec addTask et parcourez les résultats à mesure de leur arrivée avec for await.
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
}Agréger les résultats
Un groupe est une séquence asynchrone de résultats ; utilisez une réduction ou une boucle pour construire une valeur de retour unique.
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
}Groupes avec propagation d’erreurs
Utilisez withThrowingTaskGroup pour propager la première erreur ; annulez les enfants restants pour éviter le travail inutile.
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)
}
}Annuler les enfants
Appelez group.cancelAll() pour demander l’annulation. Les enfants doivent vérifier Task.isCancelled (ou Task.checkCancellation()) et se terminer rapidement.
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)
}Recommandations
Conseils :
- Préférez les groupes de tâches lorsque le nombre d’enfants est dynamique.
- Utilisez la variante throwing pour arrêter dès le premier échec.
- Videz toujours le groupe (parcourez les résultats), même après une annulation.
- Gardez les tâches enfants courtes afin que l’annulation reste réactive.
Sémantique de jointure structurée
Vérification rapide : que garantit withTaskGroup ?
Récapitulatif
Récapitulatif : utilisez withTaskGroup pour lancer du travail en parallèle et parcourir les résultats à mesure de leur arrivée ; préférez la variante throwing pour arrêter rapidement et annuler le reste.
Questions Fréquemment Posées
La leçon « TaskGroup pour le parallélisme » est-elle gratuite ?
Oui — le texte complet de « TaskGroup pour le parallélisme » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Swift Academy, passe à CoddyKit PRO. Le cours Swift Academy comprend 3 leçons au total.
Qu'est-ce que j'apprendrai dans « TaskGroup pour le parallélisme » ?
Utilisez withTaskGroup pour exécuter des tâches enfants en parallèle, parcourez les résultats à mesure de leur arrivée et gérez les échecs avec la variante qui propage les erreurs. Tu pratiques Swift Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Swift Academy ?
Aucune expérience préalable n'est requise. Swift Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 3.
Combien de temps prend la leçon « TaskGroup pour le parallélisme » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Swift Academy ?
Oui. Chaque leçon Swift Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- TaskGroup pour le parallélisme
- Acteurs et isolation des données, nonisolated
- Sendable et vérification de la sécurité des threads