0Pricing
Kotlin Academy · Leçon

Types de canaux : rendez-vous, avec tampon, fusionnés, illimités

Choisissez le type de canal adapté à votre modèle de communication.

Types de canaux : rendez-vous, avec tampon, fusionnés, illimités est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Fabrique de canaux

Créez des canaux avec Channel<T>(capacity). La capacité détermine le comportement de la mise en mémoire tampon et de la suspension.

import kotlinx.coroutines.channels.Channel
val rendezvous = Channel<Int>()              // capacity 0
val buffered   = Channel<Int>(64)            // capacity 64
val unlimited  = Channel<Int>(Channel.UNLIMITED)
val conflated  = Channel<Int>(Channel.CONFLATED)
fun main() { println("Channel types created") }

Canal de rendez-vous (capacité=0)

Canal par défaut. send suspend l’exécution jusqu’à ce qu’un récepteur soit prêt, et receive suspend l’exécution jusqu’à ce qu’un émetteur envoie une valeur. Ils se donnent rendez-vous : ils se rencontrent au même point.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>() // rendezvous
    launch {
        println("Sending...")
        ch.send(1)  // suspends until receiver is ready
        println("Sent")
    }
    delay(100)
    println("Receiving...")
    println(ch.receive())
}

Canal avec mémoire tampon

Un canal avec mémoire tampon permet à l’émetteur de continuer sans attendre tant que la mémoire tampon n’est pas pleine. Lorsqu’elle est pleine, send suspend l’exécution.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(3) // buffer of 3
    launch {
        repeat(3) {
            println("Sending $it")
            ch.send(it) // does not suspend until buffer full
        }
        ch.close()
    }
    delay(500)
    for (v in ch) println("Got $v")
}

Channel.BUFFERED

Channel.BUFFERED utilise la capacité par défaut (64). Cela équivaut à Channel(64).

import kotlinx.coroutines.channels.Channel
import kotlinx.coroutines.*
fun main() = runBlocking {
    val ch = Channel<String>(Channel.BUFFERED)
    println("Default buffer capacity is implementation-defined (~64)")
    ch.close()
}

Canal illimité

Channel.UNLIMITED ne suspend jamais l’émetteur : il met toutes les valeurs en mémoire tampon. Utilisez-le avec prudence : la mémoire peut croître sans limite.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(Channel.UNLIMITED)
    launch {
        repeat(1000) { ch.send(it) } // never suspends
        ch.close()
    }
    var sum = 0
    for (v in ch) sum += v
    println("Sum: $sum")
}

Canal à valeurs fusionnées

Channel.CONFLATED ne conserve que la valeur la plus récente. Si une nouvelle valeur arrive avant que la précédente ne soit reçue, l’ancienne est supprimée.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(Channel.CONFLATED)
    launch {
        repeat(5) { ch.send(it) } // 0..4 sent rapidly
        ch.close()
    }
    delay(50) // let all sends happen
    println("Received: ${ch.tryReceive().getOrNull()}") // likely 4 (last)
}

Synchronisation temporelle : RENDEZVOUS et BUFFERED

Le rendez-vous synchronise le producteur et le consommateur. La mémoire tampon permet au producteur de prendre de l’avance et découple leurs rythmes.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(Channel.BUFFERED)
    val t = System.currentTimeMillis()
    launch {
        repeat(5) { ch.send(it) } // fast — doesn't wait
        ch.close()
    }
    for (v in ch) { delay(100); println("$v at ${System.currentTimeMillis()-t}ms") }
}

Stratégie onBufferOverflow

Avec Channel(capacity, onBufferOverflow), choisissez ce qui se produit lorsque la mémoire tampon est pleine : SUSPEND (par défaut), supprimer l’élément le plus ancien, ou supprimer le plus récent.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ch = Channel<Int>(2, BufferOverflow.DROP_OLDEST)
    launch {
        repeat(5) { ch.trySend(it) } // 0,1,2,3,4 — buffer keeps newest 2
        ch.close()
    }
    for (v in ch) println(v) // likely 3 4
}

Choisir le type de canal

Guide de décision : le rendez-vous pour une synchronisation étroite ; la mémoire tampon pour le débit ; les valeurs fusionnées pour ne conserver que la plus récente (comme l’état de l’interface) ; le canal illimité pour la journalisation des événements lorsque aucune perte n’est acceptable.

import kotlinx.coroutines.channels.Channel
// Use cases:
// RENDEZVOUS  — handshake between producer and consumer
// BUFFERED    — decouple I/O-heavy producer from slow consumer
// CONFLATED   — UI updates (only latest matters)
// UNLIMITED   — audit log (never drop)
fun main() { println("Choose based on your loss tolerance and timing needs") }

Canal avec sélection

select permet d’attendre simultanément sur plusieurs canaux et de prendre le premier qui est prêt.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
import kotlinx.coroutines.selects.*
fun main() = runBlocking {
    val a = produce { delay(100); send("from a") }
    val b = produce { delay(50);  send("from b") }
    val result = select<String> {
        a.onReceive { it }
        b.onReceive { it }
    }
    println(result) // "from b"
    coroutineContext.cancelChildren()
}

Canal de temporisation

ticker(delay) crée un canal qui émet Unit toutes les delay millisecondes : c’est utile pour les interrogations répétées.

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*
fun main() = runBlocking {
    val ticker = ticker(delayMillis = 100, initialDelayMillis = 0)
    var count = 0
    for (tick in ticker) {
        println("Tick ${++count}")
        if (count == 3) { ticker.cancel(); break }
    }
}

Vérification rapide

Quel type de canal ne conserve que la valeur la plus récente ?

Récapitulatif

Rendez-vous : synchronisé, sans mémoire tampon. Avec mémoire tampon : découple les rythmes. Valeur fusionnée : conserve uniquement la plus récente et supprime l’ancienne. Illimité : ne suspend jamais l’émetteur. Choisissez selon votre tolérance aux pertes et vos besoins en débit.

Questions Fréquemment Posées

La leçon « Types de canaux : rendez-vous, avec tampon, fusionnés, illimités » est-elle gratuite ?

Oui — le texte complet de « Types de canaux : rendez-vous, avec tampon, fusionnés, illimités » 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 « Types de canaux : rendez-vous, avec tampon, fusionnés, illimités » ?

Choisissez le type de canal adapté à votre modèle de communication. 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 2 sur 4.

Combien de temps prend la leçon « Types de canaux : rendez-vous, avec tampon, fusionnés, illimités » ?

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

  1. Notions de base des canaux : send, receive et close
  2. Types de canaux : rendez-vous, avec tampon, fusionnés, illimités
  3. Mutex et Semaphore pour l’état partagé
  4. Acteurs et gestion structurée de l’état
← Retour à Kotlin Academy