Chapitre 1 : Limites du travail basé sur les threads et émergence des coroutines

1.1. Processus et threads JVM
1.2.
Limites de la programmation monothread et multithread
1.2.1.
Limitations des applications monothread
1.2.2.
Surmonter les limitations du monothreading grâce à la programmation multithread
1.3.
Programmation multithread utilisant des threads et des pools de threads
1.3.1.
Comment utiliser la classe Thread et ses limitations
1.3.2.
Utilisation d'un pool de threads via le framework Executor
1.3.3.
La programmation multithread et ses limitations
1.4.
Limites de la programmation multithread traditionnelle et des coroutines
1.4.1.
Limitations de la programmation multithread existante
1.4.2.
Comment les coroutines surmontent-elles les problèmes de blocage des threads ?
1.5.
addition

Chapitre 2 : Mise en place d’un environnement de développement de coroutines

2.1.
Installation et exploration d'IntelliJ IDEA
2.1.1.
Installation d'IntelliJ IDEA 58
2.2.
Créez un projet Kotlin et explorez sa mise en page.
2.2.1.
Créer un projet
2.2.2. Examen de la configuration de l'IDE
2.3.
Exécution de votre première coroutine
2.3.1.
Ajout de la bibliothèque de coroutines
2.3.2.
Exécution de votre première coroutine
2.4.
Configuration d'un environnement de débogage de coroutines
2.4.1.
Imprimer les threads en cours d'exécution
2.4.2.
Afficher le nom de la coroutine en cours d'exécution
2.4.3.
Utilisation de launch pour exécuter des coroutines supplémentaires
2.4.4.
Ajouter un nom à une coroutine à l'aide de CoroutineName
2.5.
addition

Chapitre 3 CoroutineDispatcher

3.1.
Qu'est-ce que CoroutineDispatcher ?
3.1.1.
Analyse du comportement de CoroutineDispatcher
3.1.2.
Le rôle de CoroutineDispatcher
3.2.
Répartiteurs limités et illimités
3.3.
Création d'un répartiteur restreint
3.3.1.
Création d'un répartiteur monothread
3.3.2.
Création d'un répartiteur multithread
3.4.
Exécution d'une coroutine à l'aide de CoroutineDispatcher
3.4.1.
Utilisation de CoroutineDispatcher comme paramètre de lancement
3.4.2.
Exécution d'une coroutine enfant à l'aide du CoroutineDispatcher de la coroutine parente
3.5.
Dispatcher de coroutines prédéfini
3.5.1.
Dispatchers.IO
3.5.2.
Dispatchers.Default
3.5.3.
Limiter l'utilisation des threads Dispatchers.Default à l'aide de limitedParallelism
3.5.4.
Dispatchers.IO et Dispatchers.Default4 utilisent un pool de threads partagé.
3.5.5.
Répartiteurs.Principal
3.6.
addition

Chapitre 4 : Constructeurs de coroutines et tâches

4.1.
Traitement séquentiel des coroutines à l'aide de la jointure
4.1.1.
Problèmes survenant lorsque le traitement séquentiel est impossible
4.1.2.
Traitement séquentiel utilisant la fonction de jointure
4.2.
Traitement séquentiel des coroutines à l'aide de joinAll
4.2.1.
fonction joinAll
4.2.2.
Essayez d'utiliser la fonction joinAll
4.3.
Démarrage tardif d'une coroutine avec CoroutineStart.LAZY
4.3.1.
Préparation à l'examen d'un démarrage retardé
4.3.2.
Démarrage tardif d'une coroutine avec CoroutineStart.LAZY
4.4.
Annulation d'une coroutine
4.4.1.
Annuler une tâche en utilisant Annuler
4.4.2.
Traitement séquentiel utilisant cancelAndJoin
4.5.
Confirmation de l'annulation de la coroutine
4.5.1.
Confirmation d'annulation avec délai
4.5.2.
Confirmation d'annulation utilisant yield
4.5.3.
Vérification de l'annulation à l'aide de CoroutineScope.isActive
4.6.
Variables d'état de coroutine et d'état de tâche
4.6.1.
Créez une fonction qui affiche l'état d'une tâche
4.6.2.
Coroutine en état de création
4.6.3.
Coroutine en état d'exécution
4.6.4.
La coroutine est en cours d'exécution.
4.6.5.
Annulation de la coroutine
4.6.6.
Coroutine annulée
4.6.7.
Résumé de l'état
4.7.
addition

Chapitre 5 Asynchrone et différé

5.1.
Réception du résultat via asynchrone
5.1.1.
Création d'un objet Deferred à l'aide de l'asynchrone
5.1.2.
Réception des valeurs de résultat à l'aide de await
5.2.
Le travail différé est un type d'emploi particulier.
5.3.
Réception des résultats de plusieurs coroutines
5.3.1.
Réception des résultats de plusieurs coroutines à l'aide de await
5.3.2.
Réception du résultat avec awaitAll
5.3.3.
Utilisation de awaitAll sur les collections
5.4.
avecContexte
5.4.1.
Remplacer async-await par withContext
5.4.2.
Comment fonctionne withContext
5.4.3.
Précautions à prendre lors de l'utilisation de withContext
5.5.
addition

Chapitre 6 Contexte de coroutine

6.1.
Composants du contexte de coroutine
6.2.
Configuration du contexte de coroutine
6.2.1.
Comment CoroutineContext gère les composants
6.2.2.
Configuration du contexte de coroutine
6.2.3.
Remplacement du composant CoroutineContext
6.2.4.
Combinaison de contextes de coroutine avec plusieurs composants
6.2.5.
Créez une tâche et ajoutez-la au contexte de coroutine
6.3.
Accéder au composant CoroutineContext
6.3.1.
Clés du composant CoroutineContext
6.3.2.
Accéder aux composants CoroutineContext à l'aide de clés
6.4.
Suppression du composant CoroutineContext
6.4.1.
Suppression d'éléments à l'aide de la clé moins
6.4.2.
Points à noter lors de l'utilisation de la fonction moins
6.5.
addition

Chapitre 7 Concurrence structurée

7.1.
héritage de l'environnement d'exécution
7.1.1.
Héritage de l'environnement d'exécution de la coroutine parente
7.1.2.
Écraser l'environnement d'exécution
7.1.3.
Emploi non hérité
7.1.4.
Emploi utilisé pour la structuration
7.2.
Structuration et contrôle des tâches des coroutines
7.2.1.
Propagation de l'annulation
7.2.2.
Dépendance de la complétion d'une coroutine parente vis-à-vis de sa coroutine enfant
7.3.
Gestion des coroutines à l'aide de CoroutineScope
7.3.1.
Création d'un CoroutineScope
7.3.2.
CoroutineScope, qui fournit un environnement d'exécution pour les coroutines.
7.3.3.
La portée d'une coroutine appartenant à CoroutineScope
7.3.4.
Annulation de CoroutineScope
7.3.5.
Vérification de l'état d'activation de CoroutineScope
7.4.
Structuration et emploi
7.4.1.
runBlocking et la tâche racine
7.4.2.
Briser la structure de l'emploi
7.4.3.
Utiliser des tâches pour empêcher l'annulation de certaines coroutines seulement
7.4.4.
Définissez explicitement le parent de la tâche créée.
7.4.5.
La tâche créée ne s'exécute pas automatiquement.
7.5.
addition

Chapitre 8 Gestion des exceptions

8.1.
Propagation des exceptions dans les coroutines
8.1.1.
Comment les exceptions se propagent dans les coroutines
8.1.2.
Propagation des exceptions à travers des exemples
8.2.
Restrictions de propagation des exceptions
8.2.1.
Limiter la propagation des exceptions à l'aide d'objets Job
8.2.2.
Limitation de la propagation des exceptions à l'aide de l'objet SupervisorJob
8.2.3.
Limitation de la propagation des exceptions à l'aide de supervisorScope
8.3.
Gestion des exceptions à l'aide de CoroutineExceptionHandler
8.3.1.
Créer un gestionnaire d'exceptions de coroutine
8.3.2.
Utiliser CoroutineExceptionHandler
8.3.3.
CoroutineExceptionHandler, qui ne gère que les exceptions non gérées
8.3.4.
Faites en sorte que CoroutineExceptionHandler gère les exceptions
8.3.5.
CoroutineExceptionHandler ne limite pas la propagation des exceptions.
8.4.
Gestion des exceptions à l'aide d'instructions try-catch
8.4.1.
Gestion des exceptions de coroutine à l'aide d'instructions try-catch
8.4.2.
L'instruction try-catch de la fonction de construction de la coroutine ne capture pas les exceptions de la coroutine.
8.5.
gestion des exceptions asynchrones
8.5.1.
exposition d'exception asynchrone
8.5.2.
propagation asynchrone des exceptions
8.6.
Exceptions non propagées
8.6.1.
Exception d'annulation non propagée
8.6.2.
L'exception JobCancellationException est utilisée lors de l'annulation d'une coroutine.
8.6.3.
Limiter le temps d'exécution d'une coroutine à l'aide de withTimeOut
8.7.
addition

Chapitre 9 Fonctions de suspension

9.1.
Suspension des fonctions et des coroutines
9.1.1.
Qu'est-ce qu'une fonction de suspension ?
9.1.2.
Les fonctions suspendues ne sont pas des coroutines.
9.1.3.
Exécution d'une fonction de suspension dans une coroutine séparée
9.2.
Utilisation de la fonction de suspension
9.2.1.
Points d'appel de la fonction de suspension
9.2.2.
Exécution d'une coroutine à partir d'une fonction suspendue
9.3.
addition

Chapitre 10 : Comprendre les coroutines

10.1.
Sous-programmes et coroutines
10.1.1.
Routines et sous-routines
10.1.2.
Différence entre les sous-routines et les coroutines
10.2.
Gestion des threads dans les coroutines
10.2.1.
Comprendre le passage d'un thread à travers la fonction de suspension différée
10.2.2.
Apprenez-en davantage sur la manière de rejoindre et d'attendre.
10.2.3.
Appelez la fonction yield pour libérer le thread.
10.3.
thread d'exécution de coroutine
10.3.1.
Le fil d'exécution d'une coroutine n'est pas fixe.
10.3.2.
Si vous ne cédez pas le thread, le thread d'exécution ne changera pas.
10.4.
addition

Chapitre 11 : Les coroutines en détail

11.1.
Problèmes liés aux coroutines utilisant un état partagé et la synchronisation des données
11.1.1.
Problèmes liés à l'utilisation de variables mutables
11.1.2. Comment l'espace mémoire de la JVM est connecté à la structure de mémoire matérielle.
11.1.3.
Problèmes de visibilité de la mémoire et solutions pour l'état partagé
11.1.4.
Problèmes et solutions de concurrence pour les états partagés
11.2.
Explorez les différentes options de CoroutineStart
11.2.1.
CoroutineStart.DEFAULT
11.2.2.
CoroutineStart.ATOMIQUE
11.2.3.
CoroutineStart.UNDISPATCHED
11.3.
répartiteur illimité
11.3.1.
Qu'est-ce qu'Unlimited Dispatcher ?
11.3.2.
Fonctionnalités illimitées du répartiteur
11.4.
Fonctionnement et continuation des coroutines
11.4.1.
Style de passage de continuation
11.4.2.
Comprendre la continuité par la suspension et la reprise des coroutines
11.4.3.
Reprise d'une coroutine après réception des résultats d'une autre tâche
11.5.
addition

Chapitre 12 Tests unitaires des coroutines

12.1.
Principes de base des tests unitaires
12.1.1.
Qu'est-ce qu'un test unitaire ?
12.1.2.
Mise en place d'un environnement de test
12.1.3.
Création et exécution d'un test simple
12.1.4.
Configuration d'un environnement de test à l'aide de l'annotation @BeforeEach
12.1.5.
Tester les objets dépendants à l'aide de doubles de test
12.2.
Premiers pas avec les tests unitaires de coroutines
12.2.1.
Rédiger votre premier test de coroutine
12.2.2.
Limites des tests utilisant runBlocking
12.3.
bibliothèque de test de coroutines
12.3.1.
Configuration des dépendances de la bibliothèque de tests de coroutines
12.3.2.
Exécution des tests en temps virtuel à l'aide de TestCoroutineScheduler
12.3.3.
Répartiteur de tests standard avec planificateur de coroutines de test
12.3.4.
Exécution de tests en temps virtuel avec TestScope
12.3.5.
Création de tests à l'aide de runTest
12.4.
Création d'un test unitaire de coroutine
12.4.1.
Préparation du code pour les tests unitaires de coroutines
12.4.2.
Rédaction de tests pour la classe FollowerSearcher
12,5.
Approfondissement des tests de coroutines
12.5.1.
Tests sur les objets qui exécutent de nouvelles coroutines à l'intérieur des fonctions
12.5.2.
Création de tests à l'aide de backgroundScope
12.6.
addition

Ce que ce livre couvre

- Il explique la programmation asynchrone à l'aide de coroutines, de sorte que même les développeurs débutants puissent facilement la comprendre grâce à de riches supports visuels.
- Explique les limites de la programmation multithread avant l'apparition des coroutines et comment ces dernières permettent de surmonter ces limitations.
- Explique comment utiliser les différents composants qui constituent CoroutineContext.
- Découvrez les méthodes de concurrence structurée et de gestion des exceptions des coroutines et expliquez comment stabiliser la programmation asynchrone.
- Fournit des ressources pour une compréhension approfondie du fonctionnement des coroutines.
- Explique, du niveau débutant au niveau avancé, comment écrire des tests unitaires de coroutines.

Public cible de ce livre

- Les développeurs qui souhaitent acquérir de solides connaissances sur les coroutines Kotlin, des bases jusqu'au cœur du sujet.
- Les développeurs qui souhaitent progresser techniquement en comprenant en profondeur les différentes fonctions des coroutines.
- Les développeurs qui souhaitent apprendre à rendre la programmation asynchrone plus stable en comprenant la concurrence structurée et la gestion des exceptions des coroutines.
- Les développeurs qui souhaitent comprendre le fonctionnement des coroutines
- Les développeurs qui souhaitent apprendre à écrire des tests unitaires de coroutines

Structure de ce livre

Le chapitre 1 traite des processus et des threads dans la JVM.
Nous allons explorer comment la programmation multithread traditionnelle a évolué et comment les coroutines surmontent les limitations de cette programmation.
Le chapitre 2 explique comment configurer un environnement de développement de coroutines à l'aide d'IntelliJ IDEA.
Après avoir configuré l'environnement de développement, nous exécuterons notre première coroutine et apprendrons à déterminer sur quel thread elle s'exécute.
Le chapitre 3 traite de CoroutineDispatcher.
Explique comment créer un répartiteur délimité et comment exécuter une coroutine à l'aide de ce répartiteur.
La bibliothèque de coroutines fournit des CoroutineDispatchers prédéfinis pour votre commodité ; examinons donc les types de CoroutineDispatchers prédéfinis disponibles et quand les utiliser.
Le chapitre 4 traite de la fonction de création de coroutine launch et de l'objet Job renvoyé lors de l'appel à launch.
Étant donné que les coroutines peuvent être suspendues, le traitement séquentiel entre les tâches est très important.
Nous apprendrons comment utiliser la fonction join de l'objet Job pour traiter séquentiellement les coroutines, et comment manipuler l'état des coroutines et vérifier la valeur de l'état via l'objet Job.

Le chapitre 5 explique les constructeurs de coroutines asynchrones.
Nous apprendrons à utiliser async et await pour renvoyer des valeurs depuis les coroutines, et à utiliser withContext pour changer le thread sur lequel une coroutine s'exécute.
Au chapitre 6, nous allons découvrir CoroutineContext.
Comprenez que Job, CoroutineDispatcher et CoroutineName sont des composants de CoroutineContext, et voyez comment combiner ou séparer les composants de CoroutineContext.
Le chapitre 7 explore comment la concurrence structurée est utilisée pour utiliser les coroutines en toute sécurité, en se concentrant sur la relation entre les coroutines parentes et enfants.
Ensuite, nous étudierons CoroutineScope, qui joue un rôle important dans la structuration, et nous verrons que Job est au centre de cette structuration.
Le chapitre 8 traite de la gestion des exceptions.
Nous verrons comment les exceptions se propagent lorsqu'elles surviennent dans une coroutine et nous confirmerons que cette propagation est due à la concurrence structurée.
Nous verrons également comment utiliser supervisorScope ou SupervisorJob pour limiter la portée de la propagation des exceptions.
De plus, il explique comment gérer les exceptions propagées à l'aide d'instructions try-catch ou de Coroutine ExceptionHandler.

Le chapitre 9 traite des fonctions de suspension.
Comprenez que les fonctions suspendues sont des blocs de code réutilisables et apprenez à quoi faire attention lorsque vous les utilisez.
Ensuite, nous verrons où nous pouvons appeler une fonction suspendue, comment créer un CoroutineScope à l'intérieur d'une fonction suspendue sans en perturber la structure, et comment exécuter une nouvelle coroutine enfant.
Le chapitre 10 s'appuie sur les chapitres précédents en abordant des sujets qui approfondissent votre compréhension des coroutines.
Nous allons explorer la différence entre les sous-routines et les coroutines, pourquoi la cession de threads est importante pour que les coroutines fonctionnent de manière coopérative, et ce qui se passe lorsqu'une coroutine est suspendue puis reprise.
Le chapitre 11 explore des sujets avancés concernant les coroutines.
Cet article explique les problèmes de synchronisation des données lorsqu'il existe plusieurs coroutines utilisant un état partagé dans un environnement multithread, comment modifier la méthode d'exécution d'une coroutine à l'aide de l'option CoroutineStart, comment fonctionne le répartiteur non limité et comment se produisent la suspension et la reprise des coroutines.
Le chapitre 12 traite des tests unitaires des coroutines.
Apprenez à utiliser la bibliothèque de tests de coroutines et à réaliser au mieux des tests unitaires de coroutines.

Note de l'auteur

Lors de la création de programmes, les développeurs rencontrent de nombreuses situations qui nécessitent une programmation asynchrone.
Au cours de ce processus, vous surmonterez de nombreuses difficultés et trouverez des solutions à chaque situation, vous progresserez et vous vous familiariserez avec la programmation asynchrone.
La programmation asynchrone est essentielle pour créer des programmes performants ; comprendre la programmation asynchrone est donc essentiel pour devenir un développeur compétent.
Cependant, il existe peu de ressources pédagogiques sur la programmation asynchrone.
De plus, la plupart de ces supports pédagogiques sont conçus pour des développeurs ayant un certain niveau de compétence, ce qui les rend difficiles à comprendre pour les développeurs débutants.
Les coroutines Kotlin ne font pas exception.
Les coroutines sont une solution asynchrone qui allie performance, sécurité et lisibilité, et il est clair qu'elles deviendront la norme en matière de programmation asynchrone en Kotlin pour longtemps.
Par conséquent, de nombreux développeurs ont commencé à utiliser les coroutines dans leur travail, mais il existe encore un manque de ressources pédagogiques, et la plupart sont difficiles à comprendre, en particulier pour les développeurs débutants.

J'ai essayé plusieurs choses pour rendre les coroutines plus accessibles aux développeurs.
J'ai également compilé des livres, des conférences et des documents officiels en anglais dans une série sur mon blog technique, et j'ai traduit la documentation technique officielle de Coroutine en coréen et l'ai diffusée sur le web.
Bien que ces tentatives aient été bien accueillies, la gestion systématique des coroutines présentait des limites.
J'ai alors commencé à écrire en pensant que je pourrais présenter les coroutines de manière plus systématique à travers un livre.
Ce livre traitera des coroutines de manière systématique.
Il aborde les caractéristiques de la programmation multithread traditionnelle, la manière dont les coroutines surmontent les limitations de cette programmation, les composants des coroutines et leur utilisation, etc.
Ce livre vous aidera à comprendre non seulement comment utiliser les coroutines, mais aussi les problèmes qu'elles tentent de résoudre.
Et je l'ai structuré de manière à ce que vous puissiez comprendre tout cela même si vous ne connaissez que le langage Kotlin.
J'espère que ce livre aidera de nombreux développeurs à acquérir une compréhension plus approfondie des coroutines.