Concurrence structurée en Kotlin pour Android

Concurrence Structurée en Kotlin : Enseignements de l'Audit GeminiAI par un Expert JetBrains

Le développeur Shamil Gilmetov a soumis son projet GeminiAI—un client Android pour Gemini—à un audit détaillé par Marcin Moskała, formateur certifié JetBrains et auteur de livres sur Kotlin. Le projet utilise Navigation3, Jetpack Compose, Coroutines et Flow pour implémenter des réponses en streaming de Gemini avec gestion du contexte et nettoyage automatique des ressources. L'audit a mis en lumière les forces dans l'application de la Concurrence Structurée, faisant du code un exemple de référence pour apprendre l'asynchronisme sur Android.

Marcin a salué la structure solide et la couverture des cas limites, s'ajoutant lui-même comme contributeur au dépôt. Le certificat Kotlin Expert Workshop a confirmé la qualité.

L'Évolution de l'Asynchronisme : Du GOTO à la Structure

Un article co-écrit par Gilmetov et Moskała établit un parallèle entre le code spaghetti des années 1950-60 (FLOW-MATIC avec sauts logiques) et les coroutines non structurées. Lancer des tâches sans portée conduit à des fuites : les coroutines enfants continuent de s'exécuter après l'annulation du parent, consommant des ressources.

Edsger Dijkstra en 1968, dans 'Go To Statement Considered Harmful', justifiait l'abandon du GOTO pour la prévisibilité. De même, la Concurrence Structurée introduit des limites claires pour le parallélisme.

Règles d'Or de la Concurrence Structurée

En Kotlin, trois mécanismes clés assurent le contrôle des coroutines :

• Héritage du Contexte : Les coroutines enfants reçoivent le dispatcher et d'autres paramètres du parent.
• Attente de l'Achèvement : La portée bloque jusqu'à ce que toutes les tâches launch/async à l'intérieur se terminent.
• Annulation Automatique : L'annulation ou une erreur dans le parent entraîne l'effondrement de l'arbre de tâches entier.

Exemple d'une construction basique :

coroutineScope {
    launch { /* Tâche 1 */ }
    launch { /* Tâche 2 */ }
}
// La suite seulement après achèvement des tâches

Application sur Android : ViewModel et Repository

Dans GeminiAI, ChatRepository encapsule les requêtes API vers Gemini, tandis que ViewModel gère l'annulation via viewModelScope. Lorsque le ViewModel est détruit, tous les appels réseau et le streaming sont automatiquement interrompus, minimisant les fuites mémoire.

• viewModelScope : Une portée structurée sensible au cycle de vie pour ViewModel.
• Flow dans Repository : Flux réactifs pour les états sans blocs init{}.
• Dagger-Hilt + Room : Injection de dépendances et persistance évolutives.

Cela couvre les cas limites du streaming : annuler une requête nettoie instantanément le contexte.

Avantages en Production

La Concurrence Structurée simplifie le débogage, les tests et la maintenance. Il n'y a pas de tâches 'oubliées', et le cycle de vie est prévisible. Comparé aux approches héritées (GlobalScope) :

| Approche | Fuites Mémoire | Annulation des Tâches | Cycle de Vie |

|----------|--------------|-------------------|-----------|

| GlobalScope | Risque Élevé | Manuel | Aucun |

| coroutineScope | Aucune | Auto | Structuré |

| viewModelScope | Aucune | Auto | Sensible au cycle de vie |

Le projet GeminiAI démontre l'intégration avec Jetpack Compose : navigation et mise à jour de l'UI via Flow sans bloquer l'interface.

Points Clés à Retenir

• La Concurrence Structurée élimine les fuites de tâches, similaire à l'abandon du GOTO.
• viewModelScope est la norme pour ViewModel sur Android avec annulation automatique.
• L'héritage du contexte et l'attente de l'achèvement assurent la prévisibilité.
• Application dans GeminiAI : streaming Gemini avec nettoyage des ressources.
• L'audit de Moskała a confirmé le code comme un exemple pour développeurs seniors.

— Editorial Team