Concurrence en Kotlin : des bases aux modèles avancés

Le livre « Concurrence en Kotlin : des bases aux modèles avancés » est un guide complet pour créer des applications rapides, réactives et évolutives en langage Kotlin. Si vous écrivez en Kotlin pour Android, le backend (Ktor, Spring WebFlux) ou le desktop, ce livre vous aidera à comprendre l'asynchronisme et le multithreading à un niveau approfondi.

De quoi parle ce livre ?

Le livre couvre l'ensemble du parcours, des concepts de base aux scénarios complexes de programmation concurrente. Vous apprendrez :

• Les bases de la concurrence — en quoi les threads diffèrent des coroutines, comment fonctionne le planificateur (Dispatcher) et pourquoi les coroutines sont plus légères que les threads.
• Kotlin Coroutines — lancement, annulation, concurrence structurée, Scopes, Job et Deferred.
• Sécurité des threads — variables atomiques, Mutex, Semaphore, ThreadLocal et travail avec l'état partagé.
• Canaux (Channels) — Producer-Consumer, fan-out, fan-in, canaux ticker pour le streaming de données.
• Flow et Reactive Streams — flux froids et chauds, backpressure, opérateurs de transformation, StateFlow et SharedFlow.
• Modèles avancés — Actor Model, Supervisor, CoroutineExceptionHandler, traitement parallèle avec mapAsync et flatMapMerge.
• Test du code concurrent — runTest, TestDispatcher, coroutines mock et débogage des conditions de course.

À qui s'adresse ce livre ?

• Développeurs Kotlin (Android, Backend, Multiplatform) qui souhaitent écrire du code asynchrone sans blocage.
• Développeurs juniors et intermédiaires souhaitant systématiser leurs connaissances sur les coroutines et le multithreading.
• Programmeurs passant de Java (CompletableFuture, Thread) au Kotlin moderne.
• Tous ceux qui veulent éviter les race conditions, les deadlocks et les fuites mémoire dans les applications concurrentes.

Qu'allez-vous apprendre ?

• Comment lancer et annuler correctement les coroutines sans provoquer de fuites.
• Comment choisir entre Dispatchers.Default, IO, Main et Unconfined.
• Comment construire des chaînes réactives avec Flow et gérer les erreurs dans les flux.
• Comment tester du code asynchrone à l'aide du temps virtuel.
• Comment écrire des serveurs à forte charge et des applications Android sans latence.

Le livre contient des dizaines d'exemples pratiques, prêts à être utilisés dans des projets réels. Après l'avoir lu, vous serez en mesure de concevoir en toute confiance des architectures concurrentes et d'optimiser les performances de votre code.

Remarque : Le livre est destiné aux lecteurs déjà familiarisés avec la syntaxe Kotlin. Si vous commencez tout juste à apprendre la langue, il est recommandé de suivre d'abord un cours de base.