0Pricing
Kotlin Academy · Ders

SupervisorJob ve Job: Hata Yalıtımı

Bir çocuğun hatasının kardeşlerini iptal etmesini önlemek için SupervisorJob kullanın.

SupervisorJob ve Job: Hata Yalıtımı, CoddyKit'te ücretsiz bir Kotlin Academy dersidir. Bu, 4 dersinin 1. 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.

Varsayılan İş Hatası Yayılımı

Düzenli bir Job ile alt işin başarısız olması üst işi iptal eder; üst iş de tüm kardeş işleri iptal eder. Tek bir hata, bütün hiyerarşiyi devre dışı bırakır.

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        coroutineScope {
            launch { delay(50); throw RuntimeException("child 1 failed") }
            launch { delay(1000); println("child 2 — never prints") }
        }
    } catch (e: RuntimeException) {
        println("Caught: ${e.message}")
    }
}

SupervisorJob Genel Bakışı

SupervisorJob kuralı değiştirir: bir alt işin başarısız olması kardeş işleri veya üst işi iptal ETMEZ. Her alt iş bağımsız olarak başarısız olur.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val supervisor = SupervisorJob()
    val scope = CoroutineScope(coroutineContext + supervisor)
    scope.launch { throw RuntimeException("child 1 failed") }
    scope.launch { delay(100); println("child 2 still runs") }
    delay(200)
    supervisor.cancel()
}

supervisorScope Oluşturucusu

supervisorScope { }, üst öğesi SupervisorJob olan bir kapsam oluşturur. Bağımsız alt işleri çalıştırmanın deyimsel yolu budur.

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        val job1 = launch {
            throw RuntimeException("job1 failed")
        }
        val job2 = launch {
            delay(100)
            println("job2 succeeded")
        }
        job1.join()  // wait for job1 (it failed)
        job2.join()  // job2 is unaffected
    }
}

Alt İş Hatalarını Yakalama

supervisorScope ile her alt iş kendi istisnasını yönetir. Alt işlerdeki işlenmemiş istisnalar her alt iş için ayrı ayrı yakalanmalıdır.

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        val result = async {
            delay(50)
            throw RuntimeException("async failed")
        }
        try {
            result.await()
        } catch (e: RuntimeException) {
            println("Caught from async: ${e.message}")
        }
        println("Scope continues")
    }
}

Kapsam Oluşturulurken İş ve SupervisorJob

Tek tek alt işlerin başarısız olmasından sonra da çalışması gereken bir hizmet veya ViewModel için CoroutineScope oluştururken SupervisorJob() geçirin.

import kotlinx.coroutines.*
class MyService {
    private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
    fun startTask(name: String) {
        scope.launch {
            if (name == "fail") throw RuntimeException("$name failed")
            println("$name done")
        }
    }
    fun stop() = scope.cancel()
}
fun main() = runBlocking {
    val svc = MyService()
    svc.startTask("fail")
    svc.startTask("ok")
    delay(100)
    svc.stop()
}

viewModelScope SupervisorJob Kullanır

Android'in viewModelScope'u bir SupervisorJob tarafından desteklenir. Başarısız olan tek bir başlatma, ViewModel'in diğer eş yordamlarını iptal etmez.

import kotlinx.coroutines.*
// Android ViewModel internals:
// val viewModelScope = CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate)
// Each launch is independent — one failure doesn't crash the ViewModel
fun main() = runBlocking {
    println("viewModelScope = SupervisorJob + Main")
}

supervisorScope ile Paralel Ayrıştırma

Bazı görevlerin diğerlerini etkilemeden başarısız olabileceği paralel görevler için supervisorScope + async kullanın.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val results = supervisorScope {
        val a = async { delay(50); "result-A" }
        val b = async { throw RuntimeException("B failed") }
        val c = async { delay(30); "result-C" }
        listOf(
            runCatching { a.await() },
            runCatching { b.await() },
            runCatching { c.await() }
        )
    }
    results.forEach { println(it) }
}

Normal İş Ne Zaman Kullanılmalı

Tüm alt görevlerin birlikte başarılı olması gerektiğinde normal Job (coroutineScope) kullanın — tek bir başarısızlık grubu iptal etmelidir. Bir işlem gibi: ya hep ya hiç.

import kotlinx.coroutines.*
fun main() = runBlocking {
    try {
        coroutineScope {  // regular Job
            val a = async { delay(50); "A" }
            val b = async { throw RuntimeException("B failed") }
            println(a.await())
            println(b.await())  // throws — cancels a too
        }
    } catch (e: RuntimeException) {
        println("Transaction failed: ${e.message}")
    }
}

supervisorScope İçinde İstisnaların Yayılması

supervisorScope içinde bir istisna yalnızca kapsama, alt görevin en üst düzeyinden dışarı çıkarsa yayılır — yani alt görevde try-catch yoksa. Üst görev bunu görmez.

import kotlinx.coroutines.*
fun main() = runBlocking {
    supervisorScope {
        // Exception caught inside child — scope unaffected
        launch {
            try { throw RuntimeException("handled") }
            catch (e: Exception) { println("Child caught: ${e.message}") }
        }
        delay(100)
        println("Scope survived")
    }
}

SupervisorJob ile CoroutineExceptionHandler

İşleyici bir kapsamın çökmesine neden olmadan yakalanmamış alt görev hatalarını günlüğe kaydetmek veya bunlara tepki vermek için denetleyici kapsamına bir CoroutineExceptionHandler yükleyin.

import kotlinx.coroutines.*
fun main() = runBlocking {
    val handler = CoroutineExceptionHandler { _, e ->
        println("Uncaught: ${e.message}")
    }
    val scope = CoroutineScope(SupervisorJob() + handler)
    scope.launch { throw RuntimeException("unhandled failure") }
    scope.launch { delay(100); println("still running") }
    delay(200)
    scope.cancel()
}

Hata Yalıtımı Özeti

İş: bir alt görev başarısız olur → tümü başarısız olur. Denetleyici işi: alt görevler birbirinden bağımsız olarak başarısız olur. Hizmetler ve ViewModels için denetleyici kullanın; işlemsel gruplar için normal iş kullanın.

import kotlinx.coroutines.*
// Decision table:
// coroutineScope { }   -> Job: all-or-nothing
// supervisorScope { }  -> SupervisorJob: independent failures
// CoroutineScope(SupervisorJob()) -> long-lived service
fun main() = runBlocking { println("Pick the right job for the right scope") }

Kısa Kontrol

Bir alt görevin başarısız olmasının kardeşlerini iptal etmesini hangi kapsam önler?

Özet

İş: başarısızlık kardeş görevlere yayılır. Denetleyici işi/supervisorScope: başarısızlıklar alt görev bazında yalıtılır. Bağımsız paralel görevler için supervisorScope; işlemsel gruplar için normal coroutineScope kullanın.

Sıkça Sorulan Sorular

“SupervisorJob ve Job: Hata Yalıtımı” dersi ücretsiz mi?

Evet — “SupervisorJob ve Job: Hata Yalıtı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.

“SupervisorJob ve Job: Hata Yalıtımı” dersinde ne öğreneceğim?

Bir çocuğun hatasının kardeşlerini iptal etmesini önlemek için SupervisorJob kullanı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 1. dersidir.

“SupervisorJob ve Job: Hata Yalıtı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