Présentation
de la formation
Les coroutines sont au cœur de la programmation asynchrone en Kotlin — et pourtant, leur fonctionnement interne reste méconnu de la plupart des développeurs qui les utilisent au quotidien.
Comprendre ce qui se passe sous le capot, c'est la différence entre un code concurrent qui fonctionne par chance et un code concurrent réellement maîtrisé.
Cette formation part des primitives bas niveau du langage pour remonter jusqu'aux abstractions de kotlinx.coroutines : contextes, dispatchers, annulation, concurrence structurée, channels, acteurs, flows… Autant de mécanismes à connaître pour écrire du code asynchrone correct, performant et testable.
À l'issue de ces deux jours, vous serez capables de concevoir, porter et tester du code concurrent idiomatique en Kotlin, et de choisir le bon outil pour chaque problème.
Objectifs
du programme
Comprendre le fonctionnement interne des coroutines et exploiter leurs primitives bas niveau.
Maîtriser la concurrence structurée, les scopes et la gestion de l'annulation.
Porter des API synchrones ou à base de threads vers les coroutines.
Communiquer entre coroutines avec les channels et le modèle d'acteurs.
Exploiter les flows chauds et froids, leurs opérateurs et leur partage.
Tester efficacement du code à base de coroutines.
Prérequis
Bonne maîtrise de Kotlin et expérience en développement d'applications. Une première utilisation des coroutines (suspend, launch, async) est recommandée.
Programme
J1
Des primitives à la concurrence structurée
Matin
Coroutines synchrones
séquences et générateurs, sans concurrence
Primitives bas niveau
Continuation, suspendCoroutine, createCoroutine
Contextes de coroutine
spécialiser le comportement des coroutines
Le problème du saut de thread
le comprendre et le corriger manuellement
Après-midi
Concurrence & parallélisme
modèles d'exécution et boucles d'événements
Annulation
interrompre proprement le travail en cours
Portage d'API
adapter les API synchrones et à base de threads
Scopes
structurer et composer la concurrence
J2
Channels, flows & tests
Matin
Dispatchers
répartir le travail selon les domaines
Channels
communiquer entre coroutines
Programmation par acteurs
principes et mise en œuvre
Flows chauds & froids
comprendre leurs différences
Après-midi
Partage de flows
partager et diffuser un flow
Opérateurs
transformer, combiner et filtrer les flows
Dispatching des flows
maîtriser le contexte d'exécution
Tests
tester du code à base de coroutines
Modalités
- Format
Intra-entreprise
- Durée
2 jours (14 H)
- Niveau
Expert
Ces formations pourraient vous intéresser
Nos workshops sont conçus pour les professionnels. Chaque programme est adapté au niveau et au contexte de votre équipe, en intra-entreprise ou en session ouverte.
Kotlin Multiplatformes : Mobile
Mutualisez votre code métier entre Android et iOS sans sacrifier l'expérience native : maîtrisez la toolchain Kotlin Multiplatform et l'interopérabilité Swift pour concevoir, distribuer et intégrer un SDK partagé robuste qui accélère vos équipes.
Le langage Kotlin : Concepts & outils
Découvrez comment Kotlin vous permet d'écrire moins de code, avec moins d'erreurs : ses concepts clés et ses outils vous rendront rapidement productif pour développer des applications sûres, lisibles et faciles à maintenir.
Compose : Les interfaces sous toutes leurs formes
Adoptez la pensée déclarative pour concevoir des interfaces réactives, maintenables et performantes. Maîtrisez états et flux de données pour partager une même base de code d'interface entre Android, iOS, Desktop et Web.
Le langage Kotlin : L’expertise pour déployer des API
Dépassez l'usage quotidien de Kotlin : comprenez les mécanismes profonds du langage et du compilateur pour écrire un code idiomatique et sûr, concevoir des API publiques durables et automatiser la génération de code.
Koog : Intégrer l’IA dans vos apps multiplateformes
Dépassez le simple appel à un LLM : concevez avec Koog des agents IA intégrés à vos applications Kotlin, capables d'agir et de s'orchestrer, fiables, économes et observables en production.
Gradle : Maîtriser & optimiser vos builds
Comprenez enfin ce qui se passe dans vos builds Gradle pour les rendre fiables, rapides et maintenables : factorisez votre configuration, automatisez vos besoins spécifiques et gagnez un temps précieux à chaque compilation.