launch — özü, fire-and-forget coroutine başlatma ve nasıl çalıştığı

Kotlin Coroutines'de launch nedir?

launch, kotlinx.coroutines import'u ile kullanılabilen bir Kotlin genişletme işlevidir ve belirtilen bir CoroutineScope içinde yeni bir coroutine oluşturur. Normal işlevlerin aksine, launch içindeki kod eşzamanlı olarak yürütülür — coroutine bir iş parçacığını bloke etmeden askıya alınabilir (suspend) ve daha sonra devam edebilir.

launch builder, Kotlin coroutine modelinin temel yapı taşıdır. Hesaplanmış bir değer döndürmez ancak coroutine yürütmesini kontrol etmeye izin veren bir Job nesnesi döndürür. Başka bir coroutine içinde launch ile başlatılan tüm alt coroutine'ler üst coroutine'e bağlanır.

launch'ın sözdizimi ve parametreleri

launch builder, birden çok parametreye sahip bir inline işlev olarak tanımlanır: CoroutineScope, CoroutineContext, CoroutineStart ve bir suspend bloğu. Parametrelerin varsayılan değerleri vardır, bu da launch'ı tipik senaryolar için kullanışlı hale getirir.

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job

context parametresi, bir dağıtıcı, istisna işleyicisi ve adlandırılmış öğeyi birleştiren bir CoroutineContext kabul eder. Çoğu zaman hata yalıtımı için Dispatchers.IO, Dispatchers.Main veya SupervisorJob iletilir.

Job ve yaşam döngüsü yönetimi

Job — coroutine'in yaşam döngüsünü temsil eden döndürülen nesne. Bir Job şu durumlarda olabilir: New, Active, Completing, Completed, Cancelling, Cancelled. Her durum yürütme durumunu yansıtır ve değişikliklere tepki vermeye izin verir.

val job = CoroutineScope(Dispatchers.IO).launch {
    repeat(10) { i ->
        delay(1000L)
        println("İlerleme: $i")
    }
}

println("İş aktif: ${job.isActive}")
delay(2500L)
job.cancel()
println("İş iptal edildi: ${job.isCancelled}")

Job bir hiyerarşiyi destekler: üst coroutine iptal edilirse, tüm alt coroutine'ler otomatik olarak iptal edilir. SupervisorJob bu davranışı değiştirir — alt coroutine'lerden biri başarısız olduğunda diğerleri iptal edilmez.

launch'ta yapılandırılmış eşzamanlılık

Yapılandırılmış eşzamanlılık, her coroutine'in belirli bir CoroutineScope içinde başlatıldığı ve tüm alt coroutine'ler işlerini bitirene kadar scope'un tamamlanmadığı anlamına gelir. launch bu prensibi tamamen destekler — başka bir coroutine içinde başlatılan coroutine'ler onun alt öğeleridir.

İç içe launch çağrıları

İç içe launch çağrılarıyla bir coroutine ağacı oluşur. Üst coroutine tüm alt öğelerin tamamlanmasını bekler, öngörülebilir yürütme sırası sağlar ve kaynak yönetimini basitleştirir.

fun main() = runBlocking {
    launch {
        launch {
            delay(1000L)
            println("Alt 1 tamamlandı")
        }
        launch {
            delay(500L)
            println("Alt 2 tamamlandı")
        }
        println("Tüm alt öğeler bu satırdan önce tamamlanır")
    }
}

Bu davranış, alt iş parçacıklarının üst iş parçacığına bağlı olmadığı iş parçacığı tabanlı eşzamanlılıktan farklıdır. Coroutine'lerde, tüm alt öğeler işlerini bitirene kadar üst öğe tamamlanmaz.

launch'ta istisna yönetimi

launch'ta istisna yönetimi Job türüne bağlıdır. Normal bir Job için istisnalar üst coroutine'e yayılır ve onu iptal eder. SupervisorJob veya SupervisorScope için istisnalar yalıtılır — bir alt coroutine'deki hata diğerlerini etkilemez.

val scope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
scope.launch {
    try {
        riskyOperation()
    } catch (e: Exception) {
        println("Yakalandı: ${e.message}")
    }
}
scope.launch {
    println("Bu, SupervisorJob sayesinde hala çalışıyor")
}

Yakalanmayan istisnaların genel işlenmesi için CoroutineExceptionHandler kullanılır. Coroutine içinde işlenmeyen istisnaları yakalar ve uygulamayı çökertmeden hatayı günlüğe kaydetmeye izin verir.

Android'de launch kullanım örnekleri

Android'de launch her yerde kullanılır: ViewModel'den WorkManager'a kadar. Ana desen, bileşen yaşam döngüsü sona erdiğinde coroutine'leri otomatik iptal etmek için Fragment'te lifecycleScope ve ViewModel'de viewModelScope kullanmaktır.

class ProfileViewModel : ViewModel() {
    private val repository = UserRepository()

    fun loadProfile(userId: String) {
        viewModelScope.launch(Dispatchers.IO) {
            val profile = repository.fetchProfile(userId)
            withContext(Dispatchers.Main) {
                _profileState.update { it.copy(profile = profile) }
            }
        }
    }
}

viewModelScope, ViewModel yok edildiğinde coroutine'leri otomatik olarak iptal eder. Bu, bellek sızıntılarını ortadan kaldırır ve bağlam kaybolduktan sonra arka plan işlemlerinin devam etmemesini sağlar. Ek olarak, dağıtıcılar arasında geçiş yapmak için withContext kullanılabilir.