0Pricing
Kotlin Academy · Ders

async/await İstisna Yayılımı

async kaynaklı istisnaların nasıl yayıldığını ve try-await'in ne zaman kullanılacağını anlayın.

async/await İstisna Yayılımı, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 3. dersidir. Aşağıdan dersin tamamını ücretsiz okuyabilir, sonra tarayıcıda yerleşik kod editörü ve 7/24 yapay zeka koçu ile uygulamalı olarak pratik yapabilirsin. Bu, Kotlin Academy öğrenme yolunun bir parçasıdır ve ilerlemeniz web ve CoddyKit uygulaması arasında senkronize olur. Kotlin Academy kursu toplamda 4 dersten oluşur.

Eşzamansız Çalışma İstisnaları Saklar

launch öğesinden farklı olarak async, istisnayı döndürülen Deferred içinde saklar. İstisna yalnızca await() çağrıldığında yeniden fırlatılır.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val deferred = async {
        throw RuntimeException("async error")
    }
    try {
        deferred.await()  // exception rethrown here
    } catch (e: RuntimeException) {
        println("Caught: ${e.message}")
    }
}

await() Olmadan İstisna

Hiç await() çağırmazsanız istisna, normal Job üst öğesiyle sessizce yok sayılır. supervisorScope + her zaman await kullanımını tercih edin.

import kotlinx.coroutines.*
fun main() = runBlocking {
    // Exception stored in deferred, never retrieved:
    val d = async { throw RuntimeException("lost exception") }
    delay(100)  // d has failed — exception never surfaced
    println("d.isCancelled: ${d.isCancelled}")
}

coroutineScope Altında Eşzamansız Çalışma

Normal bir coroutineScope altında, bir async alt görevi istisna fırlatır ve istisna yayılırsa (yakalanmazsa), kapsamı ve tüm kardeş görevleri iptal eder.

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        coroutineScope {
            val a = async { "A" }
            val b = async { throw RuntimeException("B failed") }
            println(a.await())
            println(b.await())  // propagates, cancels scope
        }
    } catch (e: RuntimeException) {
        println("Scope failed: ${e.message}")
    }
}

supervisorScope Altında Eşzamansız Çalışma

supervisorScope altında async kaynaklı istisnalar kardeş görevlere NOT yayılır. Her await()` ayrı ayrı sarmalanmalıdır.

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        val a = async { "A" }
        val b = async { throw RuntimeException("B failed") }
        println(a.await())
        try { println(b.await()) }
        catch (e: RuntimeException) { println("b failed: ${e.message}") }
    }
}

Birden Fazla Eşzamansız İşlem İçin awaitAll

awaitAll(d1, d2, d3) tüm ertelenmiş işlemleri bekler. Herhangi biri başarısız olursa hemen istisna fırlatır ve diğerlerini iptal eder.

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        val results = awaitAll(
            async { "result1" },
            async { throw RuntimeException("task 2 failed") },
            async { "result3" }
        )
        println(results)
    } catch (e: Exception) {
        println("awaitAll failed: ${e.message}")
    }
}

Eşzamansız Çalışma ile runCatching

Kısa devre yapmadan sonuçları ve hataları toplamak için her await() çağrısını runCatching ile sarmalayın.

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        val deferreds = listOf(
            async { "A" },
            async { throw RuntimeException("B") },
            async { "C" }
        )
        val results = deferreds.map { runCatching { it.await() } }
        results.forEach { println(it) }
    }
}

Hataları Biriktiren Paralel Görevler

Paralel eşzamansız görevlerdeki tüm başarısızlıkları toplayın ve hızlıca başarısız olmak yerine bunları birlikte raporlayın.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val tasks = listOf("a", "b", "c")
    val results = supervisorScope {
        tasks.map { t ->
            async {
                if (t == "b") throw RuntimeException("b failed")
                t.uppercase()
            }
        }.map { runCatching { it.await() } }
    }
    val errors = results.filter { it.isFailure }
    val successes = results.mapNotNull { it.getOrNull() }
    println("Success: $successes, Errors: ${errors.size}")
}

İstisna Türünü Koruma

async içinde fırlatılan istisnalar türlerini korur. Hataları hassas biçimde ele almak için await() noktasında belirli istisna türünü yakalayın.

import kotlinx.coroutines.*
class NetworkException(msg: String) : RuntimeException(msg)
fun main() = runBlocking {
    val d = async { throw NetworkException("timeout") }
    try {
        d.await()
    } catch (e: NetworkException) {
        println("Network error: ${e.message}")
    } catch (e: Exception) {
        println("Other error: ${e.message}")
    }
}

Askıya Almayan Kontrol İçin Deferred.getCompleted()

join() sonrasında sonucu eşzamanlı olarak almak için getCompleted() kullanın. Ertelenmiş işlem başarısız olduysa istisna fırlatır.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val d = async { 42 }
    d.join()  // wait without caring about result
    try {
        val result = d.getCompleted()  // synchronous — no suspend
        println("Result: $result")
    } catch (e: Exception) {
        println("Failed: ${e.message}")
    }
}

Yapılandırılmış Eşzamanlılık ve Eşzamansız Çalışma

Yapılandırılmış eşzamanlılık altında bir async ertelenmiş işlemi her zaman üst kapsamına bağlıdır. Kapsam iptal edildiğinde ertelenmiş işlem de iptal edilir — sahipsiz görevler oluşmaz.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val scope = CoroutineScope(SupervisorJob())
    val d = scope.async {
        delay(1000)
        "result"
    }
    scope.cancel()  // cancels d too
    try { d.await() }
    catch (e: CancellationException) { println("Cancelled as expected") }
}

En İyi Uygulama: Her Zaman Await Kullanın

Sonuca ihtiyacınız olmasa bile her async ertelenmiş işlem için her zaman await() kullanın. Bu, istisnaları görünür kılar ve sessiz başarısızlıkları önler.

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        val d = async {
            // do background work
            "done"
        }
        // Always await:
        val result = runCatching { d.await() }
        println(result)
    }
}

Kısa Kontrol

async { throw ... } bloğundaki istisna ne zaman ortaya çıkar?

Özet

async, istisnaları Deferred içinde saklar; bu istisnalar await() noktasında ortaya çıkar. coroutineScope altında yayılma kardeş görevleri iptal eder. supervisorScope altında her await kendi başarısızlığını ele almalıdır. Her ertelenmiş işlemi her zaman bekleyin.

Sıkça Sorulan Sorular

“async/await İstisna Yayılımı” dersi ücretsiz mi?

Evet — “async/await İstisna Yayılımı” dersin tüm metni burada web'de ücretsiz olarak okunabilir. Etkileşimli olarak pratik yapmak (yerleşik kod editörü ve 7/24 yapay zeka koçu) ve Kotlin Academy kursunun geri kalanını açmak için CoddyKit PRO'ya yükselt. Kotlin Academy kursu toplamda 4 dersten oluşur.

“async/await İstisna Yayılımı” dersinde ne öğreneceğim?

async kaynaklı istisnaların nasıl yayıldığını ve try-await'in ne zaman kullanılacağını anlayın. Kotlin Academy ile uygulamalı kodu tarayıcıda doğrudan çalıştırarak pratik yaparsın ve 7/24 yapay zeka koçu dersi çalışırken sorularını yanıtlar.

Kotlin Academy öğrenmeye başlamak için deneyim gerekli mi?

Önceden deneyim gerekmez. CoddyKit'te Kotlin Academy, başlangıçtan ileri seviyeye kadar yapılandırıldığı için buradan başlayabilir veya başından başlayıp kendi hızında ilerleme yapabilirsin. Bu, 4 dersinin 3. dersidir.

“async/await İstisna Yayılımı” dersi ne kadar sürer?

Çoğu CoddyKit dersi yaklaşık 5–10 dakika sürer. Her biri kısa ve etkileşimli olduğu için sabit ilerleme yaparsın ve web ile uygulama arasında tam olarak bıraktığın yerden devam edebilirsin.

Bu Kotlin Academy dersinde kod yazıp çalıştırabilir miyim?

Evet. Her Kotlin Academy dersi yerleşik bir kod editörü içerir, bu sayede tarayıcıda gerçek kod yazıp çalıştırabilir ve anlık yapay zeka geri bildirimi alırsın — yerel kurulum gerekli değildir.

Bu kursun tüm dersleri

  1. SupervisorJob ve Job: Hata Yalıtımı
  2. CoroutineExceptionHandler: Genel Yakalanmamış İstisna İşleyicisi
  3. async/await İstisna Yayılımı
  4. Dayanıklı Koroutin Mimarileri Tasarlama
← Kotlin Academy Sayfasına Dön