Pourquoi n'est-il pas recommandé d'utiliser des blocs de synchronisation et des constructions similaires lors du travail avec des coroutines?

L'utilisation de constructions bloquantes, telles que synchronized ou lock de la bibliothèque standard, lors de l'utilisation de coroutines conduit à une utilisation inefficace des ressources et peut causer des problèmes.

Principales raisons :

• Blocage du thread : Les blocs de synchronisation arrêtent l'exécution du thread, pas seulement des coroutines. Si une fonction Suspending est exécutée à l'intérieur d'un bloc synchronisé, le thread sera bloqué jusqu'à ce que la fonction Suspending se termine et que le verrou soit libéré. Cela peut entraîner une "faim" pour d'autres coroutines utilisant le même thread.
• Incompatibilité avec les fonctions Suspending : Le mécanisme de travail des coroutines (changement de contexte, continuations) ne prend pas en compte les blocages au niveau des threads. Exécuter une fonction Suspending dans un bloc synchronisé viole la nature non bloquante des coroutines.
• Violation des principes de concurrence structurée : Les coroutines ont leur propre système de marques d'annulation et une hiérarchie. Les blocages au niveau des threads ignorent ce système, compliquant la gestion correcte des annulations et du cycle de vie.
• Risque de deadlocks : La combinaison de blocages de threads et de mécanismes de concurrence des coroutines augmente la probabilité de deadlocks complexes, difficiles à déboguer.

Au lieu d'utiliser des blocages au niveau des threads pour la synchronisation d'accès aux ressources partagées dans les coroutines, il faut utiliser des primitives de concurrence spécialisées de la bibliothèque kotlinx.coroutines :

• Mutex : Assure une exclusion mutuelle. La coroutine qui tente d'acquérir un mutex occupé se suspend (sans bloquer le thread) jusqu'à ce que le mutex soit libéré.
• Semaphore : Limite le nombre de coroutines ayant accès simultanément à une ressource.
• Channel : Utilisé pour échanger des données entre coroutines.
• Variables atomiques : Pour des opérations atomiques simples.

Exemple d'utilisation de Mutex :

import kotlinx.coroutines.sync.Mutex
import kotlinx.coroutines.sync.withLock
import kotlinx.coroutines.*

val mutex = Mutex()
var counter = 0

suspend fun incrementCounter() {
    mutex.withLock {
        // Section critique
        counter++
    }
}

fun main() = runBlocking {
    // Créer plusieurs coroutines pour un accès concurrent
    repeat(1000) {
        launch {
            incrementCounter()
        }
    }
    delay(1000) // Donner du temps aux coroutines pour s'exécuter
    println("Counter: $counter") // On attend 1000
}

mutex.withLock est une fonction suspending. Si le mutex est occupé, la coroutine qui appelle withLock se suspend et libère le thread pour d'autres tâches. Lorsque le mutex devient disponible, la coroutine reprend. Cela ne bloque pas le thread, contrairement à synchronized.