PricingLoginStart free
Kotlin Academy · Lektion

Channel-Typen: Rendezvous, Buffered, Conflated, Unlimited

Wählen Sie den passenden Channel-Typ für Ihr Kommunikationsmuster aus.

Lektion 2 von 413 Schritte

Channel-Typen: Rendezvous, Buffered, Conflated, Unlimited ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Kotlin Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Channel-Factory

Erstellen Sie Channels mit Channel<T>(capacity). Die Kapazität bestimmt das Puffer- und Suspendierungsverhalten.

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") }

Rendezvous-Channel (capacity=0)

Standard-Channel. send suspendiert, bis ein Empfänger bereit ist, und receive suspendiert, bis ein Sender sendet. Sie treffen sich an demselben Punkt.

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())
}

Gepufferter Channel

Ein gepufferter Channel ermöglicht dem Sender, ohne Warten fortzufahren, bis der Puffer voll ist. Wenn der Puffer voll ist, suspendiert send.

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 verwendet die Standardkapazität (64). Dies entspricht 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()
}

Unbegrenzter Channel

Channel.UNLIMITED suspendiert den Sender niemals — alle Werte werden gepuffert. Verwenden Sie dies mit Vorsicht: Ein unbegrenztes Speicherwachstum ist möglich.

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")
}

Conflated Channel

Channel.CONFLATED behält nur den aktuellsten Wert. Wenn ein neuer Wert eintrifft, bevor der vorherige empfangen wurde, wird der alte verworfen.

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)
}

Zeitverhalten von RENDEZVOUS und BUFFERED

Rendezvous synchronisiert Producer und Consumer. Buffered ermöglicht dem Producer, vorauszulaufen, und entkoppelt dadurch ihr Zeitverhalten.

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") }
}

onBufferOverflow-Strategie

Mit Channel(capacity, onBufferOverflow) legen Sie fest, was geschieht, wenn der Puffer voll ist: SUSPEND (Standard), DROP_OLDEST oder DROP_LATEST.

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
}

Den richtigen Channel-Typ wählen

Entscheidungshilfe: Rendezvous für enge Synchronisierung; Buffered für hohen Durchsatz; Conflated nur für den aktuellsten Wert (z. B. einen UI-Zustand); Unlimited für die Ereignisprotokollierung, wenn Datenverluste nicht akzeptabel sind.

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") }

Channel in select

select ermöglicht das gleichzeitige Warten auf mehrere Channels und verwendet denjenigen, der zuerst bereit ist.

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()
}

Ticker-Channel

ticker(delay) erstellt einen Channel, der alle delay Millisekunden Unit emittiert — nützlich für wiederholtes Polling.

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 }
    }
}

Kurzer Test

Welcher Channel-Typ behält nur den aktuellsten Wert?

Beantworte es in der interaktiven Lektion

Zusammenfassung

Rendezvous: synchronisiert, ohne Puffer. Buffered: entkoppelt das Zeitverhalten. Conflated: nur der aktuellste Wert, alte Werte werden verworfen. Unlimited: suspendiert den Sender niemals. Wählen Sie abhängig von Ihrer Toleranz gegenüber Datenverlusten und Ihren Anforderungen an den Durchsatz.

Kostenlos starten

Lerne Kotlin mit einem KI-Tutor — kostenlos

Schreibe und führe echten Code in deinem Browser aus, bekomme sofortige Hilfe von einem 24/7 KI-Tutor und setze dein Lernen im Web oder in der App fort.

Kurse
51
Lektionen
203
Kostenlos lernenDen vollständigen Kurs ansehen

Häufig gestellte Fragen

Ist die Lektion „Channel-Typen: Rendezvous, Buffered, Conflated, Unlimited“ kostenlos?

Ja — der vollständige Text von „Channel-Typen: Rendezvous, Buffered, Conflated, Unlimited“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Kotlin Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Kotlin Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Channel-Typen: Rendezvous, Buffered, Conflated, Unlimited“?

Wählen Sie den passenden Channel-Typ für Ihr Kommunikationsmuster aus. Du übst Kotlin Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Kotlin Academy zu starten?

Keine Vorkenntnisse erforderlich. Kotlin Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „Channel-Typen: Rendezvous, Buffered, Conflated, Unlimited“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Kotlin Academy-Lektion Code schreiben und ausführen?

Ja. Jede Kotlin Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Channel-Grundlagen: send, receive und close
  2. Channel-Typen: Rendezvous, Buffered, Conflated, Unlimited
  3. Mutex und Semaphore für gemeinsam genutzten Zustand
  4. Actors und strukturierte Zustandsverwaltung
← Zurück zu Kotlin Academy