0Pricing
Kotlin Academy · Lektion

Channel-Grundlagen: send, receive und close

Erstellen Sie Channels, senden und empfangen Sie Werte und schließen Sie sie ordnungsgemäß.

Channel-Grundlagen: send, receive und close ist eine kostenlose Kotlin Academy-Lektion auf CoddyKit. Dies ist Lektion 1 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.

Was ist ein Channel?

Ein Channel ist ein Coroutine-Primitiv zur Kommunikation zwischen Coroutines — ähnlich wie eine blockierende Warteschlange, arbeitet jedoch mit Suspension. Stellen Sie sich ihn als Leitung vor: Eine Seite sendet, die andere empfängt.

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 und receive

send(value) suspendiert, bis der Empfänger bereit ist. receive() suspendiert, bis ein Wert verfügbar ist.

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

Einen Channel schließen

channel.close() signalisiert, dass keine weiteren Werte gesendet werden. Empfänger erhalten die verbleibenden gepufferten Werte; anschließend endet die for-Schleife.

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

Prüfen Sie den Channel-Status mit isClosedForSend (keine weiteren Sendungen erlaubt) und isClosedForReceive (alle Werte wurden verarbeitet).

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

Der produce-Builder

produce { } ist ein Coroutine-Builder, der eine Producer-Coroutine erstellt und einen ReceiveChannel zurückgibt. Der Channel wird automatisch geschlossen, sobald der Block endet.

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
}

Die consumeEach-Erweiterung

consumeEach { } durchläuft einen Channel und bricht ihn ab, wenn der Block eine Ausnahme auslöst, wodurch Leaks verhindert werden.

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 und trySend

Nicht suspendierende Alternativen: trySend / tryReceive geben sofort ein ChannelResult zurück, ohne zu suspendieren.

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

Fan-Out: Mehrere Consumer

Mehrere Coroutines können Werte aus demselben Channel empfangen und so die Arbeit verteilen — ein Fan-Out-Muster.

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

Fan-In: Mehrere Producer

Mehrere Coroutines können an denselben Channel senden und so ihre Ausgaben zusammenführen — ein Fan-In-Muster.

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

Pipeline-Muster

Verketten Sie Channels zu einer Pipeline, in der jede Stufe aus einem Channel liest und in einen anderen schreibt — ideal für Workflows zur Datenverarbeitung.

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

Channel im Vergleich zu Flow

Channels sind heiß und zustandsbehaftet — sie existieren unabhängig von ihrer Verarbeitung. Flows sind kalt und deklarativ — sie werden bei jeder Sammlung neu gestartet. Bevorzugen Sie Flow für Datenströme und verwenden Sie Channel für die Kommunikation zwischen Producer und Consumer.

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

Kurzer Test

Was geschieht, wenn Sie channel.close() aufrufen?

Zusammenfassung

send und receive suspendieren, bis die jeweils andere Seite bereit ist. close() signalisiert den Abschluss. Verwenden Sie produce für Producer, die sich selbst schließen, consumeEach für sicheres Iterieren und Channels für Fan-Out-/Fan-In-Muster.

Häufig gestellte Fragen

Ist die Lektion „Channel-Grundlagen: send, receive und close“ kostenlos?

Ja — der vollständige Text von „Channel-Grundlagen: send, receive und close“ 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-Grundlagen: send, receive und close“?

Erstellen Sie Channels, senden und empfangen Sie Werte und schließen Sie sie ordnungsgemäß. 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 1 von 4.

Wie lange dauert die Lektion „Channel-Grundlagen: send, receive und close“?

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