0Pricing
Kotlin Academy · Pelajaran

SharedFlow: Bus Peristiwa dan Peristiwa Sekali Jalan

Konfigurasikan replay dan extraBufferCapacity pada SharedFlow untuk menyiarkan peristiwa.

SharedFlow: Bus Peristiwa dan Peristiwa Sekali Jalan adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 2 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa Itu SharedFlow?

SharedFlow adalah aliran panas yang menyiarkan data kepada semua pengumpul aktif. Tidak seperti StateFlow, aliran ini tidak memiliki konsep nilai saat ini—aliran ini sepenuhnya digerakkan oleh peristiwa.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val events = MutableSharedFlow<String>()
    launch { events.collect { println("Collector 1: $it") } }
    launch { events.collect { println("Collector 2: $it") } }
    delay(50)
    events.emit("UserLoggedIn")
    events.emit("DataRefreshed")
    delay(50)
    coroutineContext.cancelChildren()
}

Parameter Pemutaran Ulang

replay menyimpan N emisi terakhir dalam buffer. Pengumpul baru langsung menerima hingga N peristiwa sebelumnya. Nilai bawaan adalah 0 (tanpa pemutaran ulang).

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableSharedFlow<Int>(replay = 2)
    flow.emit(1); flow.emit(2); flow.emit(3)
    // Late subscriber gets last 2:
    flow.collect { print("$it ") }  // prints 2 3
}

extraBufferCapacity

extraBufferCapacity menambahkan ruang buffer di luar pemutaran ulang. Pengirim dapat memancarkan data tanpa ditangguhkan hingga buffer penuh.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableSharedFlow<Int>(
        replay = 0,
        extraBufferCapacity = 10
    )
    // Can emit up to 10 times without a collector ready:
    repeat(10) { flow.tryEmit(it) }
    launch { flow.collect { print("$it ") } }
    delay(50)
    coroutineContext.cancelChildren()
}

tryEmit untuk Emisi Tanpa Penundaan

tryEmit(value) memancarkan data tanpa penundaan dan mengembalikan false jika buffer penuh. Gunakan dalam konteks tanpa penundaan (callback, penangan klik).

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableSharedFlow<String>(extraBufferCapacity = 5)
    val ok = flow.tryEmit("click")  // non-suspending
    println("Emitted: $ok")
    launch { flow.collect { println(it) } }
    delay(50)
    coroutineContext.cancelChildren()
}

Peristiwa Sekali Jalan (Navigasi UI)

Gunakan SharedFlow dengan replay=0 untuk peristiwa UI sekali jalan seperti navigasi atau menampilkan Snackbar—peristiwa tidak diputar ulang saat komposisi ulang.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
class NavViewModel {
    private val _events = MutableSharedFlow<String>()
    val events = _events.asSharedFlow()
    fun navigateTo(route: String) {
        // viewModelScope.launch:
        kotlinx.coroutines.GlobalScope.launch { _events.emit(route) }
    }
}
// Collect in UI:
// viewModel.events.collect { route -> navController.navigate(route) }

SharedFlow vs StateFlow

StateFlow: keadaan dengan nilai saat ini (keadaan UI). SharedFlow: peristiwa tanpa persistensi (navigasi, Snackbar, analitik). Pilih berdasarkan apakah konsumen memerlukan nilai terbaru.

import kotlinx.coroutines.flow.*
// StateFlow: always has a value; new subscribers get current value
val uiState = MutableStateFlow("idle")

// SharedFlow: no stored value; events fire and are gone (unless replay>0)
val singleEvents = MutableSharedFlow<String>(replay = 0)

fun main() { println("State = what it is; Event = what happened") }

Bus Peristiwa dengan SharedFlow

Terapkan bus peristiwa sederhana di seluruh aplikasi menggunakan SharedFlow singleton, sebagai pengganti pola PublishSubject RxJava.

import kotlinx.coroutines.flow.*
object EventBus {
    private val _events = MutableSharedFlow<Any>(extraBufferCapacity = 100)
    val events = _events.asSharedFlow()
    fun post(event: Any) { _events.tryEmit(event) }
}
sealed class AppEvent {
    object UserLoggedOut : AppEvent()
    data class ShowError(val msg: String) : AppEvent()
}
// Usage: EventBus.post(AppEvent.UserLoggedOut)

subscriptionCount

sharedFlow.subscriptionCount adalah StateFlow<Int> yang melacak jumlah pengumpul aktif—berguna untuk memulai atau menghentikan produsen hulu.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = MutableSharedFlow<Int>()
    println("Subscribers: ${flow.subscriptionCount.value}")  // 0
    val job = launch { flow.collect { } }
    delay(50)
    println("Subscribers: ${flow.subscriptionCount.value}")  // 1
    job.cancel()
    delay(50)
    println("Subscribers: ${flow.subscriptionCount.value}")  // 0
}

resetReplayCache

resetReplayCache() menghapus cache pemutaran ulang yang tersimpan di buffer. Ini berguna saat peristiwa yang diputar ulang sudah usang dan pelanggan baru tidak boleh melihatnya.

import kotlinx.coroutines.flow.*
fun main() {
    val flow = MutableSharedFlow<Int>(replay = 3)
    flow.tryEmit(1); flow.tryEmit(2); flow.tryEmit(3)
    println("Replay cache: ${flow.replayCache}")  // [1, 2, 3]
    flow.resetReplayCache()
    println("Replay cache: ${flow.replayCache}")  // []
}

Menangani Tekanan Balik dalam SharedFlow

Saat pengumpul lambat, gunakan onBufferOverflow untuk memilih: SUSPEND (bawaan), DROP_OLDEST, atau DROP_LATEST.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.channels.BufferOverflow
fun main() = runBlocking {
    val flow = MutableSharedFlow<Int>(
        replay = 0,
        extraBufferCapacity = 3,
        onBufferOverflow = BufferOverflow.DROP_OLDEST
    )
    repeat(10) { flow.tryEmit(it) }
    launch {
        flow.collect { println(it) }  // only sees most recent 3
    }
    delay(50)
    coroutineContext.cancelChildren()
}

Mengumpulkan dengan Batas Waktu

Kumpulkan SharedFlow dengan batas waktu untuk memproses sejumlah peristiwa yang terbatas lalu berhenti, yang berguna untuk pengujian atau pemrosesan berbatas.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val events = MutableSharedFlow<String>()
    launch { repeat(5) { delay(50); events.emit("Event $it") } }
    withTimeoutOrNull(200) {
        events.collect { println(it) }
    }
    println("Done collecting")
}

Pemeriksaan Cepat

Nilai pemutaran ulang apa yang sebaiknya digunakan untuk peristiwa UI sekali jalan seperti navigasi?

Ringkasan

SharedFlow adalah penyiar peristiwa aktif. Gunakan replay=0 untuk peristiwa sekali jalan dan replay>0 untuk pelanggan yang bergabung terlambat. Gunakan tryEmit dalam konteks tanpa penangguhan. Pilih SharedFlow untuk peristiwa dan StateFlow untuk status.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “SharedFlow: Bus Peristiwa dan Peristiwa Sekali Jalan” gratis?

Ya — teks lengkap “SharedFlow: Bus Peristiwa dan Peristiwa Sekali Jalan” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “SharedFlow: Bus Peristiwa dan Peristiwa Sekali Jalan”?

Konfigurasikan replay dan extraBufferCapacity pada SharedFlow untuk menyiarkan peristiwa. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 2 dari 4.

Berapa lama pelajaran “SharedFlow: Bus Peristiwa dan Peristiwa Sekali Jalan” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. StateFlow: Penampung Status Aktif untuk UI
  2. SharedFlow: Bus Peristiwa dan Peristiwa Sekali Jalan
  3. Mengubah Flow Dingin Menjadi Aktif dengan shareIn dan stateIn
  4. Menguji StateFlow dan SharedFlow dengan Turbine
← Kembali ke Kotlin Academy