Channel

import kotlinx.coroutines.channels.*

// Create a Channel
val channel = Channel<Type>()
val buffered = Channel<Type>(capacity = 10)  // With buffer

// Send
channel.send(value)      // Suspends if the buffer is full

// Receive
val value = channel.receive()   // Suspends until data arrives
channel.close()                 // Close the channel

// Receive all data with a for loop
for (v in channel) {
    println(v)
}

// produce coroutine builder
val ch = produce<Type> {
    send(value)
}

import kotlinx.coroutines.*
import kotlinx.coroutines.channels.*

fun main() = runBlocking {
    // Basic send and receive
    val channel = Channel<Int>()

    // Sender coroutine
    launch {
        for (i in 1..5) {
            channel.send(i)
            println("Sent: $i")
        }
        channel.close()  // Close the channel after sending is complete.
    }

    // Receive until the channel is closed (for loop)
    for (value in channel) {
        println("Received: $value")
    }

    // Use the produce builder to create a send-only channel.
    val squares = produce {
        for (i in 1..4) {
            send(i * i)
        }
    }
    squares.consumeEach { println("Square: $it") }
    // Square: 1, 4, 9, 16

    println("Done")
}

A Channel acts as a "pipe" between coroutines. With no buffer (the default), data is transferred the moment both sender and receiver are ready (rendezvous). A buffered channel works like a queue — sending does not block until the buffer is full.

If you do not call close() on a channel, the receiver will wait indefinitely. The produce builder automatically closes the channel when its block completes, making it convenient for send-only use cases.

For launching coroutines, see launch / async. For asynchronous data streams, see Flow — Basics.