Notions de base des canaux : send, receive et close
Créez des canaux, envoyez et recevez des valeurs, puis fermez-les correctement.
Notions de base des canaux : send, receive et close est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.
Qu’est-ce qu’un canal ?
Un canal est une primitive de coroutine qui permet aux coroutines de communiquer : c’est comme une file d’attente bloquante, mais avec suspension. Considérez-le comme un tuyau : un côté envoie et l’autre reçoit.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
val channel = Channel<Int>()
launch {
for (i in 1..5) channel.send(i)
channel.close()
}
for (x in channel) println(x) // 1 2 3 4 5
}send et receive
send(value) suspend l’exécution jusqu’à ce que le récepteur soit prêt. receive() suspend l’exécution jusqu’à ce qu’une valeur soit disponible.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
val ch = Channel<String>()
launch {
ch.send("ping")
println("sent")
}
val msg = ch.receive()
println("received: $msg")
}Fermeture d’un canal
channel.close() indique qu’aucune autre valeur ne sera envoyée. Les récepteurs obtiennent les valeurs restantes en mémoire tampon, puis la boucle for se termine.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
val ch = Channel<Int>(3)
launch {
repeat(3) { ch.send(it) }
ch.close() // signal done
}
for (v in ch) println(v) // 0 1 2, then loop ends
println("Channel consumed")
}isClosedForSend / isClosedForReceive
Vérifiez l’état du canal avec isClosedForSend (aucun nouvel envoi n’est autorisé) et isClosedForReceive (toutes les valeurs ont été consommées).
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
val ch = Channel<Int>()
launch {
ch.send(1)
ch.close()
}
println(ch.receive())
println("isClosedForReceive: ${ch.isClosedForReceive}")
}Générateur produce
produce { } est un générateur de coroutine qui crée une coroutine productrice et renvoie un ReceiveChannel. Le canal se ferme automatiquement lorsque le bloc se termine.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun CoroutineScope.squares(n: Int) = produce<Int> {
for (i in 1..n) send(i * i)
}
fun main() = runBlocking {
val sq = squares(5)
for (v in sq) println(v) // 1 4 9 16 25
}Extension consumeEach
consumeEach { } parcourt un canal et l’annule lorsque le bloc lève une exception, ce qui évite les fuites.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
val ch = produce<String> {
send("a"); send("b"); send("c")
}
ch.consumeEach { println(it) }
}tryReceive et trySend
Alternatives qui ne suspendent pas l’exécution : trySend et tryReceive renvoient immédiatement un ChannelResult, sans suspension.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
val ch = Channel<Int>(1)
val sendResult = ch.trySend(42)
println("Sent: ${sendResult.isSuccess}")
val recvResult = ch.tryReceive()
println("Got: ${recvResult.getOrNull()}")
}Répartition : plusieurs consommateurs
Plusieurs coroutines peuvent recevoir depuis le même canal et se répartir le travail : c’est un schéma de répartition.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
val tasks = produce { repeat(6) { send(it) } }
repeat(3) { worker ->
launch {
for (task in tasks) {
println("Worker $worker: task $task")
}
}
}
}Agrégation : plusieurs producteurs
Plusieurs coroutines peuvent envoyer vers le même canal et fusionner leurs sorties : c’est un schéma d’agrégation.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
val results = Channel<String>()
repeat(3) { i ->
launch { results.send("result-$i") }
}
launch {
repeat(3) { println(results.receive()) }
results.close()
}
}Schéma de chaîne de traitement
Enchaînez les canaux pour former une chaîne de traitement où chaque étape lit depuis un canal et écrit dans un autre : c’est idéal pour les flux de traitement des données.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun CoroutineScope.numbers() = produce { for (i in 1..5) send(i) }
fun CoroutineScope.doubled(input: ReceiveChannel<Int>) = produce { for (v in input) send(v * 2) }
fun main() = runBlocking {
val nums = numbers()
val doubled = doubled(nums)
for (v in doubled) println(v) // 2 4 6 8 10
coroutineContext.cancelChildren()
}Canal ou flux
Les canaux sont chauds et possèdent un état : ils existent indépendamment de la consommation. Les flux sont froids et déclaratifs : ils redémarrent à chaque collecte. Préférez Flow pour les flux de données ; utilisez un canal pour la communication entre producteur et consommateur.
import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.flow.*
// Flow (cold): each collect() re-runs the block
// Channel (hot): shared; multiple receivers share the same stream
fun main() = runBlocking { println("Flow = cold; Channel = hot") }Vérification rapide
Que se passe-t-il lorsque vous appelez channel.close() ?
Récapitulatif
send et receive suspendent l’exécution jusqu’à ce que l’autre côté soit prêt. close() signale la fin. Utilisez production pour les producteurs qui se ferment automatiquement, consumeEach pour parcourir un canal en toute sécurité, et les canaux pour les schémas de répartition et d’agrégation.
Apprends Kotlin avec un tuteur IA — gratuit
Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.
- Cours
- 51
- Leçons
- 203
Questions Fréquemment Posées
La leçon « Notions de base des canaux : send, receive et close » est-elle gratuite ?
Oui — le texte complet de « Notions de base des canaux : send, receive et close » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Notions de base des canaux : send, receive et close » ?
Créez des canaux, envoyez et recevez des valeurs, puis fermez-les correctement. Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Kotlin Academy ?
Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Notions de base des canaux : send, receive et close » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?
Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Notions de base des canaux : send, receive et close
- Types de canaux : rendez-vous, avec tampon, fusionnés, illimités
- Mutex et Semaphore pour l’état partagé
- Acteurs et gestion structurée de l’état