Flow и Channel в Kotlin — это два механизма для работы с асинхронными потоками данных, но они имеют разное назначение, модель потребления и поведение. Оба работают на базе корутин, но используются в разных сценариях.

Что такое Flow

Flow — это cold (ленивый) асинхронный поток данных, предназначенный для реактивного программирования. Он похож на Sequence, но поддерживает приостановку и асинхронность.

Пример простого flow:

fun getNumbers(): Flow<Int> = flow {
for (i in 1..3) {
delay(100)
emit(i)
}
}

Здесь getNumbers() не начнёт выполняться, пока кто-то не начнёт его собирать (collect()).

Сбор (потребление) данных из flow:

runBlocking {
getNumbers().collect { value ->
println("Received: $value")
}
}

Что такое Channel

Channel — это hot (горячий) поток данных. Он ближе по своей сути к очереди. Он создаётся сразу и может использоваться для двусторонней передачи сообщений между корутинами.

Пример использования channel:

val channel = Channel<Int>()
launch {
for (i in 1..3) {
delay(100)
channel.send(i)
}
channel.close()
}
launch {
for (msg in channel) {
println("Received: $msg")
}
}

Одна корутина отправляет данные, другая — принимает. Канал работает сразу, вне зависимости от того, кто читает.

Основные отличия Flow и Channel

Подробности о Flow

Операторы трансформации

Flow поддерживает богатый набор операторов, как в Rx:

flowOf(1, 2, 3)
.map { it \* 2 }
.filter { it > 2 }
.collect { println(it) }

Обработка ошибок

flow {
emit(1)
throw RuntimeException("Oops")
}.catch { e ->
emit(-1)
}.collect {
println(it)
}

Flow и контексты (flowOn)

flow {
emit(loadFromNetwork()) // выполняется в IO
}.flowOn(Dispatchers.IO)

Корутины в flow

Можно вызывать suspend-функции прямо внутри flow {}:

flow {
val result = fetchData() // suspend
emit(result)
}

Подробности о Channel

Типы каналов

• Channel.UNLIMITED — без ограничения буфера

• Channel.CONFLATED — только последнее значение сохраняется

• Channel.RENDEZVOUS — без буфера, send приостанавливается, пока не будет receive

• Channel.BUFFERED — с буфером (по умолчанию)

Пример с produce:

fun CoroutineScope.produceNumbers() = produce<Int> {
var x = 1
while (true) {
send(x++)
delay(100)
}
}
val numbers = produceNumbers()
launch {
repeat(5) {
println(numbers.receive())
}
numbers.cancel()
}

produce создаёт канал и возвращает ReceiveChannel, который можно слушать.

select с channel

select<Unit> {
channel1.onReceive { value ->
println("Received from channel1: $value")
}
channel2.onReceive { value ->
println("Received from channel2: $value")
}
}

Позволяет слушать сразу несколько каналов.

Когда использовать Flow

• Нужно реактивно отображать данные в UI (LiveData → StateFlow)

• Обработка событий, данных из базы или сети

• Чтение потоков с трансформацией (map, flatMapConcat)

• Простой подход, если нужен **односторонний поток данных
  **

Когда использовать Channel

• Когда есть две активные корутины, которые должны **обмениваться данными
  **

• Для реализации актеров (actors) — шаблон для обработки сообщений

• Для многопоточной связи с ручным контролем

• Когда нужен **горячий поток событий
  **

Пример: канал как шина событий

val eventChannel = Channel<Event>()
fun sendEvent(e: Event) {
scope.launch {
eventChannel.send(e)
}
}
fun startObservingEvents() {
scope.launch {
for (event in eventChannel) {
handleEvent(event)
}
}
}

Flow как альтернатива каналам

Если требуется горячий поток, лучше использовать SharedFlow или StateFlow, а не Channel, так как они безопаснее и проще в управлении:

val sharedFlow = MutableSharedFlow<Int>()
scope.launch {
sharedFlow.collect { println(it) }
}
scope.launch {
sharedFlow.emit(1)
sharedFlow.emit(2)
}

SharedFlow сохраняет поведение канала, но работает в модели Flow и более устойчив к ошибкам и утечкам.

Flow и Channel — это не конкурирующие технологии, а инструменты для разных задач. Flow — декларативный и реактивный способ описать поток данных, который возникает по требованию. Channel — механизм передачи сообщений между активными корутинами. Для реактивных сценариев в UI чаще подходит Flow, а для низкоуровневой межкорутинной связи — Channel.