Comprendre les répartiteurs dans les coroutines Kotlin

Les coroutines Kotlin offrent un moyen efficace et concis de gérer la programmation asynchrone. Au cœur des coroutines se trouve le concept de répartiteurs, qui déterminent où une coroutine sera exécutée. Les répartiteurs vous permettent de spécifier le thread ou le contexte dans lequel une coroutine s’exécute, ce qui facilite la gestion de la concurrence et du parallélisme dans votre application.

Dans cet article de blog, nous explorerons les différents types de répartiteurs disponibles dans les coroutines Kotlin et leur fournirons des exemples, y compris des répartiteurs personnalisés.

Que sont les répartiteurs ?

Les répartiteurs définissent le contexte dans lequel une coroutine s’exécute. Ils contrôlent le threading et la planification des coroutines, vous permettant d’exécuter des tâches sur différents threads en fonction du type de travail effectué. Cela permet une gestion efficace des tâches gourmandes en E/S et en CPU et des tâches qui s’exécutent sur le thread principal de l’interface utilisateur.

Choisir un répartiteur : Lors du lancement d’une coroutine, vous pouvez spécifier le répartiteur pour contrôler où la coroutine s’exécute. Si vous ne spécifiez pas de répartiteur, la coroutine utilisera le répartiteur par défaut pour votre environnement :

• Dans les environnements non Android, le répartiteur par défaut est généralement Répartiteurs.Par défautoptimisé pour les tâches gourmandes en CPU.
• Dans les environnements Android, le répartiteur par défaut peut varier en fonction du contexte :
  • Dans le thread principal d’une application Android, le répartiteur par défaut est Répartiteurs.Mainqui s’exécute sur le thread principal de l’interface utilisateur.
  • En dehors du fil principal, c’est généralement Répartiteurs.Par défaut.

Examinons les différents types de répartiteurs dans les coroutines Kotlin.

1. Répartiteurs.Par défaut

Répartiteurs.Par défaut est optimisé pour les tâches gourmandes en CPU telles que le tri de listes, le traitement d’images ou les calculs mathématiques. Il utilise un pool partagé de threads de travail.

Exemple:

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Default) {
        // This task runs on a Default dispatcher
        println("Running on Default dispatcher")
        val result = heavyComputation()
        println("Result: $result")
    }
}

suspend fun heavyComputation(): Int {
    delay(1000) // Simulate some heavy computation
    return 42
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.IO) {
        // This task runs on an IO dispatcher
        println("Running on IO dispatcher")
        val data = fetchDataFromServer()
        println("Data: $data")
    }
}

suspend fun fetchDataFromServer(): String {
    delay(1000) // Simulate network delay
    return "Fetched data"
}

import kotlinx.coroutines.*

fun main() = runBlocking(Dispatchers.Main) {
    launch {
        // This task runs on the Main dispatcher
        println("Running on Main dispatcher")
        delay(1000)
        println("Task completed on Main thread")
    }
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.Unconfined) {
        println("Running on Unconfined dispatcher")
        delay(1000)
        println("Task resumed on different context")
    }
}

import kotlinx.coroutines.*

fun main() = runBlocking {
    val customDispatcher = newSingleThreadContext("MySingleThread")

    launch(customDispatcher) {
        println("Running on custom single thread")
        delay(1000)
        println("Task completed on custom thread")
    }
}

import kotlinx.coroutines.*
import java.util.concurrent.Executors

// Create a custom dispatcher using a thread pool of 4 threads
val customDispatcher = Executors.newFixedThreadPool(4).asCoroutineDispatcher()

fun main() = runBlocking {
    launch(customDispatcher) {
        println("Running on custom dispatcher")
        delay(1000)
        println("Task completed on custom dispatcher")
    }
}

import kotlinx.coroutines.*
import java.util.concurrent.Executors

// Create a custom executor with your desired configuration
val customExecutor = Executors.newScheduledThreadPool(2)
val customDispatcher = customExecutor.asCoroutineDispatcher()

fun main() = runBlocking {
    launch(customDispatcher) {
        println("Running on custom executor dispatcher")
        delay(1000)
        println("Task completed on custom executor dispatcher")
    }
}