- Introduction
-
Coroutines Basics : introduction à l’utilisation des coroutines
- Coroutine : définition et API de base
- Appels non bloquants et mot clef suspend
- Les bases de l’API Flow
- Utilisation de l’API Job pour synchroniser des coroutines
-
Orchestration de coroutines Basics
- Async / Await
- Concurrence structurée avec coroutineScope
-
Modèle de concurrence
- Quelles threads pour exécuter les coroutines ?
- Quelles implications pour les coroutines ?
- La notion de Dispatcher et son usage
-
Job : cancel et timeout
- Comprendre le mécanisme d’annulation de coroutine
- Modèle coopératif
- Gestion du NonCancellable
- Exécution avec timeout
-
CoroutineContext
- Qu'est-ce qu’un CoroutineContext ?
- Comment y accéder et s’en servir ?
- Comment définir ses propres clés ?
- Quelles informations y sont disponibles ?
- Comment modifier le contexte d’une coroutine
-
Structured Concurrency
- Qu'est-ce qu’un CoroutineScope ?
- Lien avec un CoroutineContext et un Job
- Différence entre coroutineScope, CoroutineScope et CoroutineScope()
- Utilisation de GlobalScope
- Propagation des erreurs et cancellation
-
Gestion de la concurrence
- Approche par confinement de Thread ou de coroutine
- Utilisation de Mutex
- Utilisation de Channel : les bases
Formation Kotlin Coroutines - Avancé
Description formation Kotlin Avancé
Kotlin est un langage de programmation moderne développé par JetBrains. Ce langage statiquement typé peut être exécuté sur la JVM et est complètement interopérable avec Java. Il offre une syntaxe concise et des fonctionnalités modernes qui facilitent le développement d'applications, comme une meilleure gestion de la nullité, des capacités d’extensions et une API très riche sur les collections...
La formation Kotlin Coroutines Avancé est conçue pour les personnes maîtrisant déjà le langage Kotlin, mais n’ayant que des connaissances superficielles des coroutines et souhaitant approfondir leurs compétences. Elle couvre une variété de sujets sur l’utilisation des coroutines allant de la maîtrise des concepts au coeur de l’API (CoroutineScope, CoroutineContext, Job, Dispatcher, coroutines builders, …) jusqu’à leur fonctionnement interne et leur implémentation sous forme de continuation.
La formation s’appuie sur des éléments théoriques mais également des démonstrations et des travaux pratiques pour assurer une maîtrise complète des concepts avancés de cette API.
Pour qui ?
Cette formation informatique s’adresse à des développeurs Kotlin qui souhaitent parfaire leur maîtrise de l’API coroutine. Même si la majorité des concepts couverts est multi plateforme, certains exemples et cas d’usages s’adressent particulièrement à la cible JVM.
Prérequis
- Maîtriser les bases de la programmation objet
- Maîtriser les bases de la programmation concurrente (notion de Thread et d’accès concurrent à la mémoire)
- Maîtriser le langage Kotlin
Objectifs pédagogiques
- Maîtriser l’usage des coroutines
- Comprendre le modèle de concurrence sous jacent
- Comprendre la structured concurrency et son application
- Maîtriser les CoroutineScope et leurs usages
- Maîtriser les Job et leur application
- Savoir faire communiquer des coroutines
- Savoir interopérer les CoroutineContext et les Threads de la JVM
- Comprendre et maîtriser la gestion des erreurs et leur propagation
- Savoir traiter des flux de données asynchrones
- Appréhender l’implémentation interne des coroutines et son implication
Programme formation Kotlin Coroutines
-
Les Flow
- Comprendre la notion de cold Flow
- Flow builders, opérations intermédiaires et terminales
- Flow builder et suspend function, les recommandations
- Invariants de Flow : context preservation et exception transparency
- Les bases d’utilisation des buffers
-
Plus loin avec les Job
- Maîtriser le cycle de vie
- API Job() et CompletableJob
- Les SupervisedJob et la gestion des erreurs associée
-
Plus loin avec les coroutines builders
- Inventaire des coroutines builders et leurs différences
- Gestion du démarrage des coroutines
-
Plus loin avec les context
- Interopérabilité avec les Threads
-
Plus loin avec les Channels
- Fan in / fan out
- Gestion des buffers
- Paramétrer le fonctionnement quand le buffer est plein
- Initiation à l’utilisation du Select
-
Plus loin avec les Flow
- Hot flows : SharedFlow
- Hot flows : StateFlow
- Gestion du replayable cache
- Comprendre l’implémentation du shareIn
-
Les tests
- Bien tester les coroutines
- Gestion du temps et du delay
-
Fonctionnement interne des coroutines
- Coroutine, continuation et state machine
- Comprendre le fonctionnement des continuation par l’exemple
- Les implications sur le quotidien : debug et profiling
Modalités d'accueil
Formation(s) liée(s)
Java
DevelopTout savoir sur ce langage de programmation multiplateforme orienté objet.