PricingLoginStart free
Kotlin Academy · Pelajaran

withTimeout dan withTimeoutOrNull

Batasi waktu eksekusi dengan pembungkus timeout dan tangani TimeoutCancellationException.

Pelajaran 2 dari 413 langkah

withTimeout dan withTimeoutOrNull 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.

Mengapa Menggunakan Batas Waktu?

Korutin dapat terhenti tanpa batas pada jaringan atau operasi masukan/keluaran. withTimeout membatalkan blok jika blok tersebut tidak selesai dalam jumlah milidetik yang ditentukan.

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        withTimeout(200) {
            delay(1000)  // simulates slow network
            println("This never prints")
        }
    } catch (e: TimeoutCancellationException) {
        println("Timed out!")
    }
}

Dasar-Dasar withTimeout

withTimeout(millis) { ... } melempar TimeoutCancellationException (subkelas dari CancellationException) jika blok tersebut melampaui batas.

import kotlinx.coroutines.*
suspend fun fetchData(): String {
    delay(100)
    return "data"
}
fun main() = runBlocking {
    val result = withTimeout(500) {
        fetchData()
    }
    println(result) // data
}

withTimeoutOrNull

withTimeoutOrNull mengembalikan null saat batas waktu habis alih-alih melempar pengecualian, sehingga batas waktu lebih mudah ditangani sebagai alur normal.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val result: String? = withTimeoutOrNull(200) {
        delay(1000)
        "done"
    }
    println(result ?: "Timeout — using default")
}

Batas Waktu dengan Nilai Kembalian

Kedua fungsi mengembalikan nilai dari ekspresi terakhir dalam blok jika berhasil.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val response = withTimeoutOrNull(500) {
        delay(100)
        mapOf("status" to 200, "body" to "OK")
    }
    println(response?.get("status")) // 200
}

Batas Waktu Bersarang

Batas waktu bagian dalam habis lebih dahulu. Batas waktu bagian luar hanya berlaku jika batas waktu bagian dalam tidak membatalkan eksekusi terlebih dahulu—berguna untuk membedakan batas waktu per permintaan dan global.

import kotlinx.coroutines.*
fun main() = runBlocking {
    withTimeoutOrNull(1000) {       // global
        withTimeoutOrNull(200) {    // per-call
            delay(300)
            println("inner done")  // won't print
        } ?: println("Inner timed out")
        delay(100)
        println("outer still running")
    }
}

TimeoutCancellationException

TimeoutCancellationException adalah CancellationException, sehingga diperlakukan sebagai pembatalan normal oleh mekanisme korutin dan tidak diteruskan ke cakupan induk.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val job = launch {
        try {
            withTimeout(100) { delay(1000) }
        } catch (e: TimeoutCancellationException) {
            println("Caught in child: ${e.message}")
        }
    }
    job.join()
    println("Parent still running: ${isActive}")
}

Pembersihan Sumber Daya saat Batas Waktu Habis

Gunakan finally di dalam withTimeout untuk melepaskan sumber daya bahkan ketika waktu habis.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val result = withTimeoutOrNull(150) {
        try {
            println("Opening resource")
            delay(300)
            "result"
        } finally {
            println("Closing resource") // always runs
        }
    }
    println("Result: $result")
}

retry dengan Batas Waktu

Gabungkan batas waktu dengan logika retry: coba suatu operasi dengan batas waktu untuk setiap attempt, lalu ulangi jika hasilnya null.

import kotlinx.coroutines.*
suspend fun tryFetch(attempt: Int): String? = withTimeoutOrNull(200) {
    delay(if (attempt < 3) 300L else 100L) // fails first 2 attempts
    "success on attempt $attempt"
}
fun main() = runBlocking {
    var result: String? = null
    var attempt = 1
    while (result == null) {
        result = tryFetch(attempt++)
    }
    println(result)
}

withTimeout dalam ViewModel

Dalam ViewModel Android, bungkus panggilan repositori dengan withTimeoutOrNull di dalam viewModelScope.launch untuk menampilkan status kesalahan ketika respons lambat.

import kotlinx.coroutines.*
// Pseudocode pattern:
suspend fun loadUser(): String = withTimeoutOrNull(3000) {
    // repo.getUser()
    delay(100)
    "Alice"
} ?: "Timeout — using cached data"
fun main() = runBlocking { println(loadUser()) }

Catatan tentang Akurasi

withTimeout bergantung pada pengirim tugas korutin. Dalam pengujian yang menggunakan TestCoroutineScheduler, waktu bersifat maya dan dapat dimajukan secara manual.

import kotlinx.coroutines.*
// In unit tests with runTest:
// runTest {
//     withTimeout(1000) {
//         delay(999)  // virtual time — completes instantly
//         println("done")
//     }
// }
fun main() = runBlocking {
    println("Use runTest for virtual-time timeout testing")
}

Memilih di antara Keduanya

Gunakan withTimeout ketika batas waktu merupakan kesalahan. Gunakan withTimeoutOrNull ketika batas waktu merupakan hasil yang diharapkan (misalnya, cache tidak ditemukan atau pengambilan awal opsional).

import kotlinx.coroutines.*
fun main() = runBlocking {
    // Mandatory: throw on timeout
    // withTimeout(500) { criticalOp() }

    // Optional: null on timeout
    val cached = withTimeoutOrNull(50) {
        delay(200); "fresh"
    } ?: "stale"
    println(cached)
}

Pemeriksaan Singkat

Apa yang dikembalikan withTimeoutOrNull ketika blok tersebut melampaui batas waktu?

Jawab di pelajaran interaktif

Ringkasan

withTimeout melempar pengecualian saat batas waktu habis; withTimeoutOrNull mengembalikan null. Keduanya membatalkan blok secara kooperatif dan menjalankan blok finally. Gunakan finally untuk membersihkan sumber daya dan withTimeoutOrNull ketika batas waktu merupakan hasil yang diharapkan.

Gratis untuk memulai

Belajar Kotlin dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
51
Pelajaran
203
Mulai belajar gratisLihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “withTimeout dan withTimeoutOrNull” gratis?

Ya — teks lengkap “withTimeout dan withTimeoutOrNull” 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 “withTimeout dan withTimeoutOrNull”?

Batasi waktu eksekusi dengan pembungkus timeout dan tangani TimeoutCancellationException. 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 “withTimeout dan withTimeoutOrNull” 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. Pembatalan Kooperatif: isActive dan ensureActive
  2. withTimeout dan withTimeoutOrNull
  3. Pembersihan dengan finally dan NonCancellable
  4. Propagasi Pembatalan dalam Hierarki Coroutine
← Kembali ke Kotlin Academy