Planificateurs et gestion des fils d’exécution
Contrôlez l’exécution avec receive(on:) et subscribe(on:).
Planificateurs et gestion des fils d’exécution est une leçon Swift Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. 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 4 leçons au total.
Les ordonnanceurs dans Combine
Un ordonnanceur dans Combine définit quand et où le travail s’exécute : quel fil d’exécution ou quelle file exécute les opérateurs et transmet les valeurs aux abonnés.
Contrôler les ordonnanceurs est essentiel pour maintenir les mises à jour de l’interface utilisateur sur le fil principal et exécuter les traitements lourds en arrière-plan.
Deux opérateurs essentiels
Combine vous fournit deux opérateurs pour contrôler l’exécution sur les fils :
- subscribe(on:) — contrôle l’endroit où commencent l’abonnement et le travail en amont
- receive(on:) — contrôle l’endroit où les valeurs en aval sont transmises
Ils agissent sur des extrémités différentes de la chaîne de traitement.
receive(on:)
receive(on:) déplace tout ce qui vient après lui vers l’ordonnanceur indiqué. Le cas d’utilisation le plus courant consiste à revenir à la file principale avant de mettre à jour l’interface utilisateur.
apiClient.fetchUser(id: 1)
.receive(on: DispatchQueue.main)
.sink { user in
self.nameLabel.text = user.name
}
.store(in: &cancellables)subscribe(on:)
subscribe(on:) contrôle le fil sur lequel le publisher commence à produire des valeurs et où s’exécutent les opérateurs en amont. Utilisez-le pour déplacer l’initialisation coûteuse hors du fil principal.
heavyPublisher
.subscribe(on: DispatchQueue.global(qos: .userInitiated))
.receive(on: DispatchQueue.main)
.sink { result in
self.update(result)
}
.store(in: &cancellables)subscribe(on:) ou receive(on:)
Souvenez-vous des directions :
- subscribe(on:) agit en amont — là où le travail commence
- receive(on:) agit en aval — là où les résultats sont transmis
Un schéma courant utilise subscribe(on:) pour le travail en arrière-plan et receive(on:) pour transmettre les résultats sur le fil principal.
DispatchQueue comme ordonnanceur
DispatchQueue se conforme au protocole Scheduler. DispatchQueue.main transmet les valeurs sur le fil principal ; les files globales s’exécutent simultanément en arrière-plan.
let background = DispatchQueue.global(qos: .background)
publisher
.map { expensiveTransform($0) }
.subscribe(on: background)
.receive(on: DispatchQueue.main)
.sink { self.render($0) }
.store(in: &cancellables)RunLoop comme ordonnanceur
RunLoop est un autre ordonnanceur, associé à la boucle d’exécution d’un fil. RunLoop.main transmet les valeurs en coordination avec les événements de l’interface utilisateur, ce qui peut être important pour des éléments comme la réactivité du défilement.
timerPublisher
.receive(on: RunLoop.main)
.sink { _ in
self.tick()
}
.store(in: &cancellables)DispatchQueue ou RunLoop
Les deux peuvent transmettre les valeurs sur le fil principal, mais ils présentent de subtiles différences :
- DispatchQueue.main — planifie le travail même pendant le suivi du défilement
- RunLoop.main — reporte le travail lorsque la boucle d’exécution est en mode de suivi
Pour la plupart des mises à jour de l’interface utilisateur après un travail asynchrone, DispatchQueue.main constitue le choix par défaut le plus sûr.
Opérateurs temporels des ordonnanceurs
Les opérateurs comme debounce, throttle et delay reçoivent tous un argument d’ordonnanceur qui détermine quelle file gère leur temporisation.
searchTextPublisher
.debounce(for: .milliseconds(300), scheduler: DispatchQueue.main)
.sink { query in
self.runSearch(query)
}
.store(in: &cancellables)Un bogue courant lié aux fils d’exécution
Mettre à jour l’interface utilisateur hors du fil principal provoque des plantages ou des anomalies visuelles. Si vous oubliez receive(on: DispatchQueue.main) après un publisher exécuté en arrière-plan, votre sink peut s’exécuter sur un fil d’arrière-plan.
Transmettez toujours les valeurs destinées à l’interface utilisateur sur l’ordonnanceur principal.
Mettre tout en pratique
Une chaîne de traitement robuste démarre le travail en arrière-plan, l’y traite, puis transmet les résultats au fil principal pour l’affichage.
imageURLPublisher
.subscribe(on: DispatchQueue.global())
.flatMap { url in downloadImage(url) }
.map { resize($0) }
.receive(on: DispatchQueue.main)
.sink { self.imageView.image = $0 }
.store(in: &cancellables)Vérification rapide
Vérifiez vos connaissances sur les ordonnanceurs.
Récapitulatif
Vous avez appris à contrôler l’exécution sur les fils dans Combine :
- subscribe(on:) — là où commence le travail en amont
- receive(on:) — là où les résultats sont transmis
- DispatchQueue et RunLoop comme ordonnanceurs
- Transmettez toujours les mises à jour de l’interface utilisateur sur le fil principal
Une planification appropriée maintient les applications réactives et exemptes de plantages.
Questions Fréquemment Posées
La leçon « Planificateurs et gestion des fils d’exécution » est-elle gratuite ?
Oui — le texte complet de « Planificateurs et gestion des fils d’exécution » 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 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Planificateurs et gestion des fils d’exécution » ?
Contrôlez l’exécution avec receive(on:) et subscribe(on:). 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 2 sur 4.
Combien de temps prend la leçon « Planificateurs et gestion des fils d’exécution » ?
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
- Transformer et combiner des flux
- Planificateurs et gestion des fils d’exécution
- Opérateurs de gestion des erreurs
- Éditeurs et abonnés personnalisés