
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
mekanizmasıdır.Çünkü Android'de, neredeyse her coroutine bir görünümle (view) ilişkilidir ve eğer bu görünüm yok
edilirse, ona bağlı olan coroutineler gereksiz hale gelir ve iptal edilmelidir. Benzer şekilde, uygulama kapandığında
diğer coroutineler de iptal edilmelidir. Bu, geçmişte birçok kütüphane ile çok fazla çaba gerektiren kritik bir
yetenekti, ancak Kotlin Coroutines, basit ve güvenli bir iptal mekanizması sunar. Bu mekanizma, özellikle uzun süreli
bağlantılar (örneğin, WebSockets veya long polling) ile çalışırken backend tarafında da kullanılabilir. Üstelik, çoğu
zaman iptalin kaynakları serbest bırakma ve uygulamayı daha verimli hale getirme gibi ek faydalar sağladığını fark
etmeyiz.
öncelikle iptali desteklemek için kullanır1Android'deki
CoroutineWorker buna iyi bir örnektir. Google'da Android üzerine çalışan. Bunun iyi bir nedeni vardır: İyi bir iptal mekanizması son derecedeğerlidir2Aslında, iptal mekanizmasının sağladığı avantajlar çok daha değerlidir.. Bir iş parçacığını (thread) doğrudan sonlandırmak kötü bir çözümdür, çünkü bağlantıları kapatmak ve
kaynakları serbest bırakmak için bir fırsat sunulmalıdır. Geliştiricilerin sürekli olarak bir işlemin hala aktif olup
olmadığını kontrol etmeye zorlanması da pratik değildir. İptal problemi uzun süre boyunca iyi bir çözüm beklemiş, ancak
Kotlin Coroutines tarafından sunulan çözüm şaşırtıcı derecede basit, kullanışlı ve güvenlidir. Kariyerimde gördüğüm en
iyi iptal mekanizmasıdır. Gelin, bunu daha ayrıntılı inceleyelim.
Job nesnesi üzerinden cancel fonksiyonu çağrıldığında, job'undurumu "Cancelling" (İptal Ediliyor) olarak değiştirilir. Bu değişikliğin şu sonuçları vardır:
- Bu job'a bağlı olan tüm alt job'lar da iptal edilir.
- Job artık yeni coroutine'ler için üst job olarak kullanılamaz.
- İlk askıya alma (suspension) noktasında bir
CancellationExceptionfırlatılır. Eğer coroutine şu anda askıya alınmış
durumdaysa,CancellationExceptionile hemen devam ettirilir.CancellationException, coroutine oluşturucuları (
builder) tarafından yoksayılır, bu nedenle onu yakalamak gerekli değildir. Ancak, coroutine gövdesinin mümkün olan en
kısa sürede tamamlanmasını sağlamak için kullanılır. - Coroutine gövdesi tamamlandığında ve tüm alt coroutine'leri de tamamlandığında, job'un durumu "Cancelled" (İptal
Edildi) olarak güncellenir.
import kotlinx.coroutines.delay import kotlinx.coroutines.launch import kotlinx.coroutines.coroutineScope /** * Bu örnekte bir coroutine'in nasıl başlatılacağı, izleneceği ve iptal * edileceği gösterilmektedir. */ //sampleStart suspend fun main(): Unit = coroutineScope { // launch fonksiyonu yeni bir coroutine başlatır ve bir Job nesnesi döndürür // Job, coroutine'i kontrol etmek için kullanılabilir val job = launch { // 1000 kez tekrar eden bir döngü başlatılıyor repeat(1_000) { i -> // Her yinelemede 200 milisaniye bekleniyor // delay, thread'i bloke etmeden asenkron bekleme sağlar delay(200) // Mevcut döngü sayısı yazdırılıyor println("Yazdırılıyor $i") } } // Ana coroutine 1.1 saniye bekliyor // Bu süre zarfında yukarıdaki launch içindeki kod çalışmaya devam eder delay(1100) // job.cancel() çağrısı, coroutine'i iptal etmek için kullanılır // Bu, coroutine içindeki işlemi nazikçe durdurmaya çalışır job.cancel() // job.join() çağrısı, coroutine tamamen sonlanana kadar bekler // İptal edilen bir coroutine için, iptal işleminin tamamlanmasını bekler job.join() // İptal işlemi tamamlandıktan sonra bu mesaj gösterilir println("Başarıyla iptal edildi") } // Çıktı açıklaması: // (0.2 saniye) // Yazdırılıyor 0 - İlk yineleme 200ms sonra // (0.2 saniye) // Yazdırılıyor 1 - İkinci yineleme 400ms'de // (0.2 saniye) // Yazdırılıyor 2 - Üçüncü yineleme 600ms'de // (0.2 saniye) // Yazdırılıyor 3 - Dördüncü yineleme 800ms'de // (0.2 saniye) // Yazdırılıyor 4 - Beşinci yineleme 1000ms'de // (0.1 saniye) // Başarıyla iptal edildi - 1100ms'de job.cancel() çağrıldı ve işlem tamamlandı
launch fonksiyonu, her 200 milisaniyede bir sayı yazdıran bir süreç başlatır. Ancak, 1100 milisaniye sonrabu süreci iptal ederiz. Bu nedenle coroutine'in durumu "Cancelling" olarak değişir ve ilk askıya alma
noktası (
delay) geldiğinde bir CancellationException fırlatılır. Bu istisna, coroutine gövdesinintamamlanmasını sağlar, böylece coroutine "Cancelled" durumuna geçer,
join devam eder ve ekrana"Başarıyla iptal edildi" mesajı yazdırılır.
cancelfonksiyonuna bir istisna nesnesi argüman olarak verilebilir. Ancak, kullanılacak istisna mutlaka
CancellationException türünün bir alt türü olmalıdır, çünkü yalnızca bu türdeki istisnalar bir coroutine'iiptal etmek için kullanılabilir.
finally bloğu varsa, iptal edilse bile bu blokkesinlikle çalıştırılır ve tüm kaynaklar serbest bırakılır. Ayrıca,
CancellationException yakalayarakyalnızca iptal durumunda bir işlem gerçekleştirmemizi sağlar.
rethrow) zorunlu değildir, çünkü coroutine oluşturucu (builder)tarafından otomatik olarak göz ardı edilir. Ancak, dış kapsamın iptal hakkında bilgi sahibi olması
gerekiyorsa,
CancellationException yeniden fırlatmak iyi bir uygulama olarak kabul edilir.import kotlinx.coroutines.* /** * Bu örnek, coroutine'lerde iptal mekanizmasını ve hata işleme mantığını göstermektedir. */ //sampleStart suspend fun main(): Unit = coroutineScope { // Yeni bir coroutine başlatılıyor ve job referansı alınıyor val job = launch { try { // 1000 tekrarlı bir işlem başlatılıyor repeat(1_000) { i -> // Asenkron olarak 200 ms bekleniyor delay(200) // Mevcut döngü sayısı yazdırılıyor println("Yazdırılıyor $i") } } catch (e: CancellationException) { // İptal edildiğinde bu blok çalışır // CancellationException, coroutine iptal edildiğinde fırlatılan // özel bir istisna tipidir println("İptal edildi: $e") // İstisnayı yeniden fırlatmak önemlidir, böylece üst coroutine // iptalden haberdar olur throw e // İstisna dış kapsama iletiliyor } finally { // İster normal tamamlansın ister iptal edilsin, bu blok her durumda çalışır // Kaynakları temizlemek için ideal yerdir println("Finally bloğu çalıştırıldı") } } // Ana coroutine 700 ms bekliyor // Bu süre zarfında yukarıdaki coroutine 3 döngü çalıştırabilir delay(700) // Coroutine'i iptal etme isteği gönderiliyor job.cancel() // Coroutine'in tamamen sonlanmasını bekliyor // İptal sonrası coroutine içindeki catch ve finally blokları çalışır job.join() // İptal süreci tamamlandıktan sonra bu mesaj yazdırılıyor println("Başarıyla iptal edildi") // Son olarak 1 saniye daha bekleniyor delay(1000) } // Çıktı açıklaması: // (0.2 saniye) // Yazdırılıyor 0 // (0.2 saniye) // Yazdırılıyor 1 // (0.2 saniye) // Yazdırılıyor 2 // (0.1 saniye) // İptal edildi: JobCancellationException... // Finally bloğu çalıştırıldı // Başarıyla iptal edildi //sampleEnd
join fonksiyonu, coroutine'in iptal işleminin tamamlanmasını beklemek içindir. Bufonksiyon olmadan bir yarış durumu (race condition) oluşabilir ve büyük ihtimalle ekranda "Başarıyla iptal edildi"
ifadesini, "İptal edildi..." ve "Finally" ifadelerinden önce görürüz. Bu nedenle, bir coroutine'i iptal ettiğimizde,
genellikle iptal işleminin tamamlanmasını beklemek için
join fonksiyonunu da çağırırız.cancelAndJoin adlı açıklayıcı isme sahip birgenişletme fonksiyonu (extension function) sunmaktadır3Bu fonksiyon, önce
cancel çağırarak coroutine'i iptal eder, ardından join./** * Bir Job nesnesini iptal eder ve iptal işleminin tamamlanmasını bekler. * Bu fonksiyon, bir coroutine'i nazikçe durdurmak ve işlemin tam olarak * tamamlanmasını beklemek için kullanılır. */ public suspend fun Job.cancelAndJoin() { // Önce job'u iptal et // Bu, job'un durumunu "Cancelling" olarak değiştirir ve // coroutine içindeki işlemi bir sonraki askıya alma noktasında durdurur cancel() // İptal işleminin tamamlanmasını bekle // Bu çağrı, job "Cancelled" durumuna geçene kadar // (yani coroutine tamamen sonlanana kadar) askıya alınır // join() fonksiyonunun dönüş değerini döndür (genellikle Unit) return join() }
Job arayüzündeki invokeOnCompletion fonksiyonunukullanmaktır. Bu fonksiyon, job son durumuna ("Completed" veya "Cancelled") ulaştığında çalıştırılacak bir işleyici (
handler) tanımlamak için kullanılır. Ayrıca coroutine'in tamamlanmasına yol açan istisna (varsa) parametre olarak
sağlanır.
invokeOnCompletion fonksiyonunun, coroutine tamamlandığında tam olarak bir kez çağrılması garanti edilir (coroutine'in bir şekilde tamamlandığı varsayıldığında). Bu işleyici, job zaten tamamlanmış olsa bile sonradan ayarlansa
dahi çağrılır.
import kotlinx.coroutines.* /** * Bu örnek, job.invokeOnCompletion ile coroutine tamamlanma işleyicisinin * nasıl kullanılacağını göstermektedir. */ //sampleStart suspend fun main(): Unit = coroutineScope { // Yeni bir coroutine başlatılıyor ve job referansı alınıyor val job = launch { // 1000 tekrarlı bir işlem başlatılıyor repeat(1_000) { i -> // Asenkron olarak 200 ms bekleniyor delay(200) // Mevcut döngü sayısı yazdırılıyor println("Yazdırılıyor $i") } } // invokeOnCompletion, job tamamlandığında veya iptal edildiğinde // çalıştırılacak bir işlev kaydeder job.invokeOnCompletion { // it parametresi, eğer job bir hata ile sonlandıysa o hatayı içerir // Normal tamamlanma durumunda null olur if (it is CancellationException) { // Job iptal edilirse bu blok çalışır println("İptal edildi: $it") } // Her durumda (normal tamamlanma veya iptal) bu satır çalışır println("Sonlandırıldı") } // Ana coroutine 700 ms bekliyor // Bu süre zarfında yukarıdaki coroutine 3 döngü çalıştırabilir delay(700) // Coroutine'i iptal etme isteği gönderiliyor job.cancel() // Coroutine'in tamamen sonlanmasını bekliyor // İptal sonrası tamamlanma işleyicisindeki kod çalışır job.join() // İptal süreci tamamlandıktan sonra bu mesaj yazdırılıyor println("Başarıyla iptal edildi") // Son olarak 1 saniye daha bekleniyor delay(1000) } // Çıktı açıklaması: // (0.2 saniye) // Yazdırılıyor 0 // (0.2 saniye) // Yazdırılıyor 1 // (0.2 saniye) // Yazdırılıyor 2 // (0.1 saniye) // İptal edildi: JobCancellationException... // Sonlandırıldı // Başarıyla iptal edildi
invokeOnCompletion işleyicisi aşağıdaki durumlarda çağrılır:- Eğer coroutine herhangi bir hata olmadan tamamlanmışsa, parametre olarak
nulldeğeriyle çağrılır. - Coroutine iptal edilmişse, parametre olarak
CancellationExceptiondeğeriyle çağrılır. - Coroutine'i sonlandıran bir hata oluşmuşsa, parametre olarak bu hata ile çağrılır (bu konu sonraki bölümde detaylı
incelenecektir).
invokeOnCompletion, iptal işlemi sırasında senkron olarak çağrılır ve hangi iş parçacığında (thread) çalıştırılacağınıkontrol edemeyiz. Ayrıca bu fonksiyon,
onCancelling4Eğer bu parametre true olarak ayarlanırsa, ilgili fonksiyon "Cancelling" ve invokeImmediately5Bu parametre, bir coroutine zaten istenen durumda olduğunda, belirtilen işleyicinin parametreleri kullanılarakdaha fazla özelleştirilebilir.
iptal edilir. Bu durum son derece kullanışlıdır; bir işlemi iptal ettiğinizde, o işlemle ilişkili tüm alt işlemler de
iptal olur. Bu yaklaşım, bellek sızıntılarını (memory leaks) önlemek ve kaynakları serbest bırakmak açısından iyi bir
uygulamadır.¬
import kotlinx.coroutines.* /** * Bu örnek, bir ebeveyn coroutine iptal edildiğinde alt coroutine'lerin * davranışını ve farklı hata işleme yaklaşımlarını göstermektedir. */ suspend fun main(): Unit = coroutineScope { // Alt coroutine'lerden birine dışarıdan erişmek için referans var childJob: Job? = null // Ana coroutine başlatılıyor val job = launch { // İlk alt coroutine: finally bloğu ile temizlik işlemi yapıyor launch { try { delay(1000) println("A") } finally { // İptal edilse bile bu blok çalışacak println("A tamamlandı") } } // İkinci alt coroutine: CancellationException'ı yakalıyor childJob = launch { try { delay(2000) println("B") } catch (e: CancellationException) { // İptal istisnasını özel olarak ele alıyor println("B iptal edildi") } } // Üçüncü alt coroutine: tamamlanma işleyicisi kullanıyor launch { delay(3000) println("C") }.invokeOnCompletion { // Coroutine ister normal tamamlansın ister iptal edilsin çalışacak println("C tamamlandı") } } // Coroutine'lerin başlaması için kısa bir süre bekliyoruz delay(100) // Ana coroutine'i iptal ediyoruz // Bu, tüm alt coroutine'leri otomatik olarak iptal eder job.cancel() // Ana coroutine'in tamamlanmasını bekliyoruz job.join() // İptal işlemi tamamlandı println("Başarıyla iptal edildi") // childJob'un durumunu kontrol ediyoruz // Ebeveyn iptal edildiğinde tüm alt coroutine'ler de iptal edilir println(childJob?.isCancelled) } // Çıktı açıklaması: // (0.1 saniye) // (aşağıdaki sıralama farklı olabilir) // A tamamlandı // B iptal edildi // C tamamlandı // Başarıyla iptal edildi // true
Job() fonksiyonu kullanılarak oluşturulan bir job da aynı şekilde iptal edilebilir. Genellikle coroutine kapsamını (CoroutineScope) oluştururken bir job belirtiriz. Eğer açıkça bir job belirtilmemişse, CoroutineScope varsayılan birjob oluşturur.
/** * Bu kod, Kotlin Coroutines kütüphanesindeki CoroutineScope oluşturucu fonksiyonunu * göstermektedir. */ fun CoroutineScope( // Coroutine kapsamı için kullanılacak bağlam (context) context: CoroutineContext ): CoroutineScope = ContextScope( // Eğer verilen bağlamda Job zaten varsa mevcut bağlamı kullan // Aksi takdirde bağlama yeni bir Job ekle if (context[Job] != null) context else context + Job() )
CoroutineScope), coroutine'ler için üst job olarak kullanıldığında, üst job'u iptal ederek tümcoroutine'leri aynı anda iptal edebiliriz. Bunu yapmak için
CoroutineScope içindeki cancel fonksiyonu kullanılır; bufonksiyon, ilgili job üzerinde
cancel çağrısını gerçekleştirir./** * Bu kod, CoroutineScope uzantı fonksiyonu olan cancel'ı göstermektedir. * Bir coroutine kapsamını iptal etmek için kullanılır. */ fun CoroutineScope.cancel(cause: CancellationException? = null) { // Coroutine bağlamından Job nesnesini al val job = coroutineContext[Job] ?: error("Scope içinde Job bulunamadı") // Job'u iptal et (opsiyonel olarak iptal sebebi belirtilerek) job.cancel(cause) }
testlerinde (unit testing) tüm işlemlerin tamamlanmasını sağlamak amacıyla faydalı olabilir.
/** * Bu sınıf, coroutine'leri kullanarak teklifleri yükleyen ve gerektiğinde tüm yükleme * işlemlerini iptal edebilen bir OfferUploader'ı temsil eder. */ class OfferUploader { // IO dispatcher üzerinde çalışacak özel bir coroutine kapsamı // Ağ işlemleri gibi IO-bound işlemler için uygun private val scope = CoroutineScope(Dispatchers.IO) /** * Verilen teklifi asenkron olarak yükler * * @param offer Yüklenecek teklif nesnesi */ fun upload(offer: Offer) { scope.launch { // Burada asenkron yükleme işlemleri gerçekleştirilecek // upload } } /** * Tüm yükleme işlemlerini iptal eder * Örneğin sınıf imha edilirken veya kullanıcı işlemi durdurduğunda çağrılabilir */ fun cancel() { // Özel kapsamdaki tüm coroutine'leri iptal et scope.cancel() } }
Bu nedenle, iptal edilmiş bir job içeren bir kapsam (
CoroutineScope) artık kullanışlı değildir. Hatta bu durumtehlikeli olabilir, çünkü böyle bir kapsam içinde yeni bir coroutine başlatmaya çalışmak sessizce hiçbir işlem
yapmadan devam eder.
import kotlinx.coroutines.* /** * Bu örnek, iptal edilmiş bir kapsamda coroutine başlatma girişiminin davranışını * gösterir. */ suspend fun main() { // Yeni bir Job ile CoroutineScope oluşturuluyor val scope = CoroutineScope(Job()) // Kapsam hemen iptal ediliyor scope.cancel() // İptal edilmiş bir kapsamda yeni bir coroutine başlatılmaya çalışılıyor val job = scope.launch { // Bu blok hiçbir zaman çalıştırılmayacak println("Bu satır yazdırılmayacak") } // İptal edilmiş kapsam nedeniyle coroutine hiç başlamadığı için // join() çağrısı anında tamamlanır job.join() }
CoroutineContext içinde bulunan cancelChildren fonksiyonunun kullanılmasını öneririm.Bu fonksiyon, bir job'un tüm alt job'larını iptal eder ancak job'un kendisini aktif durumda bırakır.
Job'un aktif kalması herhangi bir ek maliyet oluşturmaz ve ek güvenlik sağlar.
viewModelScope veya lifecycleScope kullanıldığında iptal işlemi otomatik olarak gerçekleşir.Ancak, kendi kapsamımızı oluşturduğumuzda, bu kapsam artık gerekli olmadığında alt job'larını iptal etmeyi
unutmamalıyız. Bu tür kapsamlar için üst job olarak
SupervisorJob kullanmak iyi bir uygulamadır. Bunun neden önemliolduğunu bir sonraki bölümde açıklayacağım.
/** * Android ViewModel sınıfı, coroutines kullanarak asenkron işlemleri * yöneten bir örnek. */ class ProfileViewModel : ViewModel() { // UI thread'de çalışacak ve hata izolasyonu için SupervisorJob // kullanan bir coroutine kapsamı private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob()) /** * ViewModel oluşturulduğunda kullanıcı verilerini yükle */ fun onCreate() { scope.launch { loadUserData() } } /** * ViewModel imha edildiğinde çalışan metot * Tüm aktif coroutine'leri iptal eder */ override fun onCleared() { // Tüm alt coroutine'leri iptal et, ana SupervisorJob'ı korur scope.coroutineContext.cancelChildren() } // ... }
ve tamamlanması gerekir. Ancak, kaynakları temizleme işlemi askıya alınabilir (
suspending) çağrılar yapmayı veyayeni coroutine başlatmayı gerektirirse ne olur?
bir fonksiyon çağırmak
CancellationException fırlatır ve yeni bir coroutine başlatmaya çalışmak sessizce göz ardıedilir.
import kotlinx.coroutines.* /** * Bu örnek, iptal edilen bir coroutine'in finally bloğunda askıya alınabilir * fonksiyonların ve yeni coroutine'lerin davranışını göstermektedir. */ suspend fun main(): Unit = coroutineScope { // Yeni bir Job oluşturuluyor, bu Job çocuk coroutine'leri kontrol edecek val job = Job() // Job ile ilişkilendirilmiş bir coroutine başlatılıyor launch(job) { try { println("Coroutine başlatıldı") delay(200) // 200ms bekliyor, fakat iptal 100ms'de gerçekleşecek println("Coroutine tamamlandı") // İptal nedeniyle bu satır çalışmayacak } finally { // İptal işleminden sonra her durumda finally bloğu çalıştırılacak println("Finally bloğu çalıştırıldı") // İptal edilmiş bir coroutine içinde yeni bir coroutine başlatma girişimi launch { println("Alt coroutine çalıştırıldı") // Bu satır çalışmayacak } // İptal edilmiş bir coroutine içinde askıya alınabilir bir fonksiyon çağrısı delay(1000L) // Bu askıya alma işlemi de çalışmayacak println("Temizleme işlemi tamamlandı") // Bu satır da çalışmayacak } } // Ana coroutine'de 100ms bekleniyor delay(100) // Oluşturulan job iptal ediliyor ve tamamlanması bekleniyor job.cancelAndJoin() println("Tamamlandı") } // Çıktı: // Coroutine başlatıldı // (0.1 saniye sonra) // Finally bloğu çalıştırıldı // Tamamlandı
withContext(NonCancellable) kullanılabilir."Cancelling" durumunda bile çalıştırılması gereken tüm askıya alınabilir (
suspending) çağrılar içinwithContext(NonCancellable) kullanmalıyız.NonCancellable, her zaman aktif olan bir job'dur ve yalnızca bu özel durum için kullanılmalıdır.Bu yapı, iptal edilse bile askıya alınabilir bir işlem gerçekleştirmemiz veya yeni bir coroutine
başlatmamız gerektiğinde kullanılır.
import kotlinx.coroutines.* /** * Bu örnek, iptal edilen bir coroutine içinde NonCancellable context kullanarak * iptal edilemez bir kapsamda işlem yapmanın nasıl çalıştığını göstermektedir. */ suspend fun main(): Unit = coroutineScope { // Yeni bir Job oluşturuluyor val job = Job() // Job ile ilişkilendirilmiş bir coroutine başlatılıyor launch(job) { try { println("Coroutine başlatıldı") delay(200) // 200ms bekliyor, fakat iptal 100ms'de gerçekleşecek println("Coroutine tamamlandı") // İptal nedeniyle bu satır çalışmayacak } finally { // İptal işleminden sonra her durumda finally bloğu çalıştırılacak println("Finally bloğu çalıştırıldı") // NonCancellable context ile iptal edilemez bir kapsamda işlem yapılıyor withContext(NonCancellable) { // İptal durumunda bile çalıştırılacak işlemler // Bu kapsamda başlatılan coroutine çalışacak launch { println("Alt coroutine çalıştırıldı") } // Bu kapsamda askıya alınabilir fonksiyonlar iptal edilmez delay(1000L) // 1 saniye bekleme gerçekleşir // Bu satır çalışacak println("Temizleme işlemi tamamlandı") } } } // Ana coroutine'de 100ms bekleniyor delay(100) // Oluşturulan job iptal ediliyor ve tamamlanması bekleniyor job.cancelAndJoin() println("Tamamlandı") } // Çıktı: // Coroutine başlatıldı // (0.1 saniye sonra) // Finally bloğu çalıştırıldı // Alt coroutine çalıştırıldı // (1 saniye sonra) // Temizleme işlemi tamamlandı // Tamamlandı
suspending) fonksiyon uyguluyorsanız ve finally bloğu içinde askıyaalınabilir bir çağrı gerektiren bir temizleme işlemi yapmanız gerekiyorsa, bu işlemin iptal durumunda bile
çalıştırılmasını sağlamak için
withContext(NonCancellable) kullanmalısınız. Aşağıdaki örnekte, finally bloğundatemizleme işlemi gerçekleştirilirken
withContext(NonCancellable) kullanılarak, iptal edilse bile bu işlemintamamlanması garanti edilir.
/** * Güvenli kaynak temizleme için iptal durumlarına karşı dayanıklı * bir coroutine işlem deseni. */ suspend fun operation() { try { // Ana işlemler burada gerçekleştirilir // Örneğin: // - Veritabanından veri çekme // - Ağ istekleri yapma // - Dosya işlemleri gerçekleştirme // - Uzun süren hesaplamalar } finally { // İşlem iptal edilse bile temizleme işlemleri mutlaka çalıştırılacak withContext(NonCancellable) { // Burada askıya alınabilir (suspending) fonksiyonlar // iptal edilmeden güvenle çağrılabilir // Örnek temizleme işlemleri: // - delay(1000) // Beklemeler iptal edilmeyecek // - veritabanı.kapat() // Veritabanı bağlantısı güvenle kapatılabilir // - dosya.kapat() // Dosya tanıtıcıları güvenle kapatılabilir // - network.disconnect() // Ağ bağlantıları güvenle sonlandırılabilir } } }
iptal edilmez.Bu durumu simüle etmek için
delay yerine Thread.sleep kullanılabilir, ancak bu çok kötü biruygulamadır ve gerçek projelerde kesinlikle yapılmamalıdır.Burada yalnızca, coroutine'leri yoğun bir şekilde
kullandığımız ancak askıya almadığımız bir senaryoyu göstermek istiyoruz. Gerçek dünyada bu tür bir durum, ağır
hesaplamalar (örneğin, sinir ağı eğitimi(neural network learning) gibi paralelleştirilmesi gereken işlemler) veya
bloklayıcı çağrılar(örneğin, dosya okuma gibi işlemler) sırasında ortaya çıkabilir. Aşağıdaki örnek, bir coroutine
içinde herhangi bir askıya alma noktası bulunmadığından iptal edilemeyen bir durumu göstermektedir.
delay yerineThread.sleep kullanıldığı için, işlem 1 saniye sonra iptal edilmesi gerekirken 3 dakikadan uzun sürmektedir.import kotlinx.coroutines.* suspend fun main(): Unit = coroutineScope { val job = Job() launch(job) { repeat(1_000) { i -> // 1. Yöntem: Her iterasyonda iptal kontrolü yapma if (!isActive) return@repeat // veya throw CancellationException() // Bloke edici çağrı yerine coroutine API'yi kullan // Thread.sleep(200) -> delay(200) delay(200) // Bu otomatik olarak iptal kontrolü yapar println("Yazdırılıyor $i") } } delay(1000) job.cancelAndJoin() println("Başarıyla iptal edildi") delay(1000) } // Çıktı: // Yazdırılıyor 0 // Yazdırılıyor 1 // Yazdırılıyor 2 // Yazdırılıyor 3 // Yazdırılıyor 4 // Başarıyla iptal edildi
yield() fonksiyonunu kullanmaktır.yield() fonksiyonu bir coroutine'i askıya alır ve hemen devam ettirir. Bu, askıya alma sırasında iptal işlemleriningerçekleşmesine veya iş parçacığının (thread) değiştirilmesine olanak tanır. Böylece, uzun süren işlemler sırasında
coroutine'in iptale duyarlı hale gelmesi sağlanabilir.
import kotlinx.coroutines.* // Bu örnekte kooperatif iptal (cooperative cancellation) gösterilmektedir. // Ana fonksiyon coroutineScope içinde çalıştırılıyor, böylece tüm alt coroutine'ler // bu scope bitene kadar tamamlanacak suspend fun main(): Unit = coroutineScope { // Yeni bir Job nesnesi oluşturuluyor. Bu, coroutine'in // yaşam döngüsünü kontrol etmek için kullanılacak val job = Job() // job ile ilişkilendirilmiş yeni bir coroutine başlatılıyor launch(job) { // 1000 kez tekrarlanacak bir döngü başlatılıyor repeat(1_000) { i -> // Thread.sleep bloklayıcı bir çağrıdır ve coroutine iptal edilebilirliğini desteklemez // Yani bu çağrı sırasında coroutine iptal edilemez Thread.sleep(200) // yield() fonksiyonu coroutine'i geçici olarak askıya alır ve iptal durumunu // kontrol eder Eğer coroutine iptal edilmişse, bu noktada CancellationException fırlatılır // ve döngü sonlanır yield() // Coroutine iptal edilmemişse, i değeri yazdırılır println("Yazdırılıyor $i") } } // Ana coroutine 1100 milisaniye bekler // Bu süre içinde alt coroutine yaklaşık 5-6 iterasyon gerçekleştirebilir delay(1100) // job iptal edilir ve tamamlanması beklenir // cancelAndJoin(), cancel() ve join() işlemlerini birleştirir // cancel(): Job'u iptal eder // join(): Job'un tamamlanmasını bekler job.cancelAndJoin() // İptal işlemi tamamlandıktan sonra bu mesaj yazdırılır println("Başarıyla iptal edildi") // Program sonlanmadan önce 1 saniye daha beklenir delay(1000) } // Program çıktısı: // Yazdırılıyor 0 - İlk iterasyon // Yazdırılıyor 1 - İkinci iterasyon // Yazdırılıyor 2 - Üçüncü iterasyon // Yazdırılıyor 3 - Dördüncü iterasyon // Yazdırılıyor 4 - Beşinci iterasyon // Başarıyla iptal edildi - İptal işlemi tamamlandı
yield fonksiyonunukullanmak iyi bir uygulamadır. Bu, coroutine'in iptale duyarlı hale gelmesini sağlar ve sistem kaynaklarının
daha verimli kullanılmasına yardımcı olur.
// CPU yoğun işlemleri gerçekleştirmek için ayrı bir coroutine içinde çalışan suspend fonksiyon suspend fun cpu() = withContext(Dispatchers.Default) { // İlk CPU yoğun işlem - bu işlem sırasında iptal kontrolü yapılmaz cpuIntensiveOperation1() // İptal kontrolü noktası - eğer coroutine iptal edilmişse, burada işlem sonlanır // Aynı zamanda diğer coroutine'lerin çalışması için işbirliği yapar yield() // İkinci CPU yoğun işlem - önceki yield() sonrası iptal edilmediyse çalışır cpuIntensiveOperation2() // İkinci iptal kontrolü noktası - iptal durumunu tekrar kontrol eder yield() // Son CPU yoğun işlem - önceki iki işlem ve iptal kontrolleri tamamlandıysa çalışır cpuIntensiveOperation3() }
this ifadesi ocoroutine'in kapsamına (scope) referans verir.
CoroutineScope, coroutineContext özelliği aracılığıyla bağlamınaerişmemizi sağlar. Böylece,
coroutineContext[Job] veya coroutineContext.job kullanarak coroutine'in job bileşenineerişebilir ve mevcut durumunu kontrol edebiliriz. Job'un aktif olup olmadığını kontrol etmek yaygın bir işlem
olduğundan, Kotlin Coroutines kütüphanesi bu işlemi kolaylaştıran bir fonksiyon sağlar.
// Bu uzantı özelliği (extension property), bir CoroutineScope'un aktif olup olmadığını kontrol eder public val CoroutineScope.isActive: Boolean // coroutineContext'ten Job elementi alınır ve bu Job'un aktif olup olmadığı kontrol edilir // Eğer Job null ise (bu scope bir Job içermiyorsa), varsayılan olarak true döndürülür get() = coroutineContext[Job]?.isActive ?: true
isActiveözelliğini kullanabiliriz.
import kotlinx.coroutines.* // Ana fonksiyonu coroutineScope içinde başlat - // bütün alt coroutine'ler bitene kadar bekler suspend fun main(): Unit = coroutineScope { // İptal edilebilir bir Job oluştur val job = Job() // Bu Job altında yeni bir coroutine başlat launch(job) { do { // Thread.sleep bloklayıcı bir işlemdir ve coroutine'in iptal edilmesini engellemez // Ancak her döngü döndüğünde isActive durumu kontrol edilir Thread.sleep(200) // Her 200ms'de bir mesaj yazdır println("Yazdırılıyor") // isActive, coroutine'in iptal edilip edilmediğini kontrol eden bir özellik // Job iptal edilirse isActive false olur ve döngü sonlanır } while (isActive) } // Ana coroutine 1100 ms bekler - bu süre zarfında alt coroutine // yaklaşık 5-6 mesaj yazdırabilir delay(1100) // Job'u iptal et ve tamamlanmasını bekle job.cancelAndJoin() // İptal işlemi tamamlandığında son mesajı yazdır println("Başarıyla iptal edildi") } // Program çıktısı: // Yazdırılıyor // Yazdırılıyor // Yazdırılıyor // Yazdırılıyor // Yazdırılıyor // Yazdırılıyor // Başarıyla iptal edildi
ensureActive() fonksiyonunu kullanabiliriz.Bu fonksiyon, job aktif değilse birCancellationException fırlatır.import kotlinx.coroutines.* // Ana fonksiyonu coroutineScope içinde başlat - bütün alt coroutine'ler bitene kadar bekler suspend fun main(): Unit = coroutineScope { // İptal edilebilir bir Job oluştur val job = Job() // Bu Job altında yeni bir coroutine başlat launch(job) { // 1000 kez tekrarlayan bir döngü oluştur, her döngüde sıra numarası ile işlem yap repeat(1000) { num -> // Thread.sleep bloklayıcı bir işlemdir ve coroutine'in iptal edilmesini kontrol etmez Thread.sleep(200) // ensureActive() fonksiyonu, isActive'den farklı olarak iptal durumunu aktif olarak // kontrol eder Eğer coroutine iptal edilmişse, bu noktada CancellationException // fırlatır ve işlem sonlanır ensureActive() // İptal edilmediyse, sıra numarasıyla birlikte mesaj yazdırır println("Yazdırılıyor $num") } } // Ana coroutine 1100 ms bekler - bu süre zarfında alt coroutine yaklaşık 5 mesaj yazdırabilir delay(1100) // Job'u iptal et ve tamamlanmasını bekle job.cancelAndJoin() // İptal işlemi tamamlandığında son mesajı yazdır println("Başarıyla iptal edildi") } // Program çıktısı: // Yazdırılıyor 0 // Yazdırılıyor 1 // Yazdırılıyor 2 // Yazdırılıyor 3 // Yazdırılıyor 4 // Başarıyla iptal edildi
ensureActive() ve yield() fonksiyonlarının sonuçları benzer görünse de aslında çok farklıdır.-
ensureActive()fonksiyonu birCoroutineScope,CoroutineContextveyaJobüzerinden çağrılmalıdır. Tek yaptığı
şey, job artık aktif değilse bir istisna (CancellationException) fırlatmaktır.ensureActive()fonksiyonu oldukça
hafif bir işlemdir. -
yield()fonksiyonu ise herhangi bir kapsam (scope) gerektirmeyen, askıya alınabilir (suspending) üst seviye (
top-level) bir fonksiyondur.yield()bir coroutine'i askıya alır ve ardından devam ettirir. Bu süreçte iş
parçacığı (thread) serbest bırakılabilir ve sırası gelene kadar çalışmayı bekleyebilir.
yield(), iş parçacığı kullanımı yüksek olan işlemlerde yararlıdır çünkü iş parçacıklarının verimli kullanılmasınısağlar ve diğer coroutine'lerin bloke olmasını önler. Bu yüzden, CPU yoğun veya bloklayıcı işlemler içeren askıya
alınabilir fonksiyonlarda
yield() kullanılması önerilir.CancellationException istisnası fırlatılır ve bu, coroutineler açısından özel biranlama sahiptir. Bu nedenle,
CancellationException, diğer istisnalar ile birlikte ele alınmamalı ve genel istisnaişleme mekanizmaları içinde yakalanmamalıdır.
CancellationException yutulursa,coroutine iptal mekanizması düzgün çalışmayabilir ve bu durum, kaynakların serbest bırakılmasını veya işlemlerin doğru
bir şekilde sonlandırılmasını engelleyebilir.
CancellationException istisnası yakalandığında,istisna doğrudan yeniden fırlatılmaktadır. Bunun yanında, diğer tüm istisnalar ayrı bir
catch bloğunda işlenebilir.// Coroutine içinde çalışacak bir suspend fonksiyon suspend fun operation() { try { // Bu bölümde askıya alınabilen (suspendable) işlemler gerçekleştirilir // Örneğin: delay(), withContext(), diğer suspend fonksiyonlar vb. } catch (e: CancellationException) { // CancellationException, coroutine iptal edildiğinde fırlatılan özel bir istisnadır // Bu istisna yutulmamalıdır, aksi takdirde coroutine iptal mekanizması düzgün çalışmaz // Bu yüzden istisna tekrar fırlatılarak iptal sinyalinin yayılması sağlanır throw e // İptal mekanizmasının doğru çalışmasını sağlamak için istisna yeniden fırlatılıyor } catch (e: Exception) { // Diğer tüm istisnalar burada yakalanıp işlenebilir // Bu, coroutine'in başka sebeplerden dolayı çökmesini engeller // Örneğin: loglama, hata durumunu bildirme, kurtarma işlemleri vb. } }
catch bloğuna ensureActive() ekleyerek coroutine'in hâlâ aktif olup olmadığını kontroledebiliriz. Bazı geliştiriciler bu yaklaşımı daha güvenli bulmaktadır, çünkü bu yöntem yalnızca mevcut coroutine
aktif olduğunda istisna fırlatır ve
CancellationException başka nedenlerle tetiklendiğinde coroutine'iniptalini yanlış yorumlamaz.
catch bloğunda coroutineContext.ensureActive() kullanılarak coroutine'in hâlâ aktif olupolmadığı kontrol edilmektedir. Eğer coroutine iptal edilmemişse, işlem devam edebilir.
// Coroutine içinde çalışacak bir suspend fonksiyon suspend fun operation() { try { // Bu bölümde askıya alınabilen (suspendable) işlemler gerçekleştirilir // Örneğin: delay(), withContext(), diğer suspend fonksiyonlar vb. } catch (e: Exception) { // Tüm istisnalar burada yakalanır (CancellationException dahil tüm Exception türevleri) // Eğer coroutine iptal edildiyse, aşağıdaki kontrol CancellationException fırlatacak // Bu satır sayesinde, istisnayı yakalasak bile coroutine'in iptal durumunu göz ardı etmiyoruz coroutineContext.ensureActive() // Coroutine'in hâlâ aktif olup olmadığını kontrol eder // Eğer coroutine aktifse (iptal edilmediyse), buraya kadar gelir ve // istisna ile ilgili işlemler (loglama, telemetri, kurtarma vb.) yapılabilir } }
CancellationException istisnasını açıkçayakalayabiliriz. Ancak, iptal durumunun dış kapsama doğru şekilde iletilmesi için bu istisna her zaman yeniden
fırlatılmalıdır. Aksi takdirde, coroutine iptal edilmiş olmasına rağmen, dış kapsam bunu algılayamayabilir ve yanlış
davranışlara yol açabilir. Aşağıdaki örnekte,
CancellationException istisnası yakalandığında belirli bir işlemgerçekleştirilmektedir, ancak istisna hemen ardından yeniden fırlatılmaktadır.
// Coroutine içinde çalışacak bir suspend fonksiyon suspend fun operation() { try { // Bu bölümde askıya alınabilen (suspendable) işlemler gerçekleştirilir // Örneğin: delay(), withContext(), diğer suspend fonksiyonlar vb. } catch (e: Exception) { // Tüm istisnalar burada yakalanır (CancellationException dahil tüm Exception türevleri) // Eğer coroutine iptal edildiyse, aşağıdaki kontrol CancellationException fırlatacak // Bu satır sayesinde, istisnayı yakalasak bile coroutine'in iptal durumunu göz ardı etmiyoruz coroutineContext.ensureActive() // Coroutine'in hâlâ aktif olup olmadığını kontrol eder // Eğer coroutine aktifse (iptal edilmediyse), buraya kadar gelir ve // istisna ile ilgili işlemler (loglama, telemetri, kurtarma vb.) yapılabilir } }
CancellationException,java.util.concurrent.CancellationException ile aynı değildir. İkincisi Java'da Future arayüzü için kullanılır veKotlin Coroutines kütüphanesinin bir parçası değildir. değildir. Bu iki istisna farklı amaçlar için farklı
kütüphanelerde kullanılır:
CancellationException sınıfından türetilen tüm istisnalar özel bir şekilde ele alınır: yalnızca mevcut coroutine'iiptal eder, üst coroutine'e yayılmaz.
CancellationException, açık (open) bir sınıftır. Bu nedenle, kendisınıflarımızı veya nesnelerimizi bu sınıftan türeterek özelleştirilmiş iptal istisnaları oluşturabiliriz.
import kotlinx.coroutines.* // CancellationException sınıfından türeyen özel bir istisna - bu tür istisnalar coroutine sınırları dışına yayılmaz class MyNonPropagatingException : CancellationException() suspend fun main(): Unit = coroutineScope { // İlk coroutine scope bloğu başlatılıyor - bu 1. coroutine olarak adlandırılır launch { // 1. Üst coroutine başlatılıyor // İlk coroutine'in içinde ikinci bir iç coroutine başlatılıyor - bu coroutine, üst coroutine iptal edildiğinde otomatik olarak iptal edilecek launch { // 2. İç coroutine başlatılıyor // Bu coroutine 2 saniye beklemek üzere ayarlanır, ancak üst coroutine 1 saniye sonra iptal edildiği için bu bekleme tamamlanamaz delay(2000) // 2 saniye bekleniyor // Bu satır asla çalışmayacak, çünkü içinde bulunduğu coroutine, üst coroutine iptal edildiğinde iptal edilecek println("Bu satır yazdırılmayacak") } // Üst coroutine 1 saniye bekliyor, bu sürenin sonunda bir istisna fırlatacak delay(1000) // 1 saniye bekleniyor // CancellationException fırlatılınca bu coroutine ve alt coroutine'leri iptal edilir, fakat diğer kardeş coroutine'ler etkilenmez throw MyNonPropagatingException() // 3. Özel bir CancellationException fırlatılıyor } // İkinci bir paralel coroutine başlatılıyor - bu coroutine birinci coroutine'den tamamen bağımsızdır launch { // 4. Paralel bir coroutine başlatılıyor // Bu coroutine de 2 saniye bekliyor, ancak diğer coroutine'deki istisna bunu etkilemez delay(2000) // 2 saniye bekleniyor // Bu satır çalışacak çünkü bu coroutine hiçbir zaman iptal edilmedi println("Bu satır yazdırılacak") } } // Program çalıştıktan 2 saniye sonra ikinci coroutine'in delay'i tamamlanır ve println çalışır // (2 saniye sonra) // Bu satır yazdırılacak
MyNonPropagatingException fırlatılır. Bu istisna, CancellationException sınıfının bir alt türü olduğu için, launchbloğu (1 numaralı coroutine) tarafından yakalanır.
- 1 numaralı coroutine kendini iptal eder ve bağlı olduğu tüm alt coroutine'leri (2 numaralı coroutine) de iptal eder.
- Ancak,
CancellationExceptionistisnaları üst coroutine'e yayılmadığından,coroutineScopeve onun içindeki
diğer coroutine'ler (4 numaralı coroutine) etkilenmez. - Bu nedenle, 4 numaralı coroutine 2 saniye sonra
"Bu satır yazdırılacak"ifadesini ekrana yazdırır.
CancellationException sınıfından türetilen özel istisnaların tanımlandığını görüyorum. Bu tehlikelibir uygulamadır, çünkü beklenmeyen sonuçlara yol açabilir. Aşağıdaki kodu ele alalım:
import kotlinx.coroutines.* import kotlin.coroutines.cancellation.CancellationException // Kötü bir uygulama, bunu yapmayın // CancellationException, coroutine iptal durumları için ayrılmış bir istisna türüdür, normal iş mantığı hataları için kullanılmamalıdır class UserNotFoundException : CancellationException() suspend fun main() { // UserNotFoundException bir CancellationException olmasına rağmen, burada normal bir istisna gibi yakalanabilir // Normal şartlarda CancellationException yakalanmamalıdır try { updateUserData() } catch (e: UserNotFoundException) { // Bu kod çalışır çünkü CancellationException coroutine scope dışında normal bir istisna gibi davranır println("Kullanıcı bulunamadı") } } suspend fun updateUserData() { // updateUser fonksiyonu bir istisna fırlatacak updateUser() // Bu satır hiçbir zaman çalışmayacak çünkü önceki satırda istisna fırlatılıyor updateTweets() } suspend fun updateTweets() { // Bu fonksiyon hiçbir zaman çağrılmayacak çünkü updateUser bir istisna fırlatacak delay(1000) println("Güncelleniyor...") } suspend fun updateUser() { // İş mantığı hatası için CancellationException kullanmak kötü bir uygulama // CancellationException, coroutine'lerin iptal edilmesi için özel bir mekanizmadır // Normal hatalar için standart Exception türleri kullanılmalıdır throw UserNotFoundException() } // Program çıktısı - istisna yakalandığı için bu mesaj gösterilir // Kullanıcı bulunamadı
arasında herhangi bir coroutine bulunmamasıdır. Eğer iki işlem arasına bir
launch bloğu eklenirse, programın davranışıönemli ölçüde değişebilir ve beklenmeyen sonuçlar ortaya çıkabilir.
import kotlinx.coroutines.* import kotlin.coroutines.cancellation.CancellationException // Kötü bir uygulama, bunu yapmayın // İş mantığı hataları için CancellationException kullanmak hatalı bir yaklaşımdır class UserNotFoundException : CancellationException() suspend fun main() { // Bu try-catch bloğu çalışmayacak, çünkü CancellationException // sadece kendi coroutine scope'unda yakalanır try { updateUserData() } catch (e: UserNotFoundException) { // Bu kod hiçbir zaman çalıştırılmayacak, çünkü istisna coroutineScope içinde ele alınıyor println("Kullanıcı bulunamadı") } } // coroutineScope ile yapılandırıldığı için, içindeki tüm coroutine'ler // tamamlanana kadar bu fonksiyon dönmez suspend fun updateUserData() = coroutineScope { // İlk coroutine: updateUser çağrısı yapılır ve bu bir istisna fırlatacak launch { updateUser() } // Kullanıcı güncellenirken bir istisna fırlatılacak // İkinci coroutine: Birinci coroutine'den bağımsız olarak çalışır launch { updateTweets() } // Ancak bu coroutine etkilenmeden çalışmaya devam edecek } suspend fun updateTweets() { // Bu fonksiyon 1 saniye bekler ve ardından mesaj yazdırır delay(1000) println("Güncelleniyor...") } suspend fun updateUser() { // CancellationException türünden bir istisna fırlatır.Bu türdeki istisnalar // sadece kendi coroutine'ini iptal eder, kardeş coroutine'lere yayılmaz throw UserNotFoundException() // `CancellationException` türetildiği için üst coroutine'e yayılmayacak } // Bir saniye bekledikten sonra ikinci coroutine tarafından yazdırılır // (1 saniye sonra) // Güncelleniyor...
updateUser fonksiyonu UserNotFoundException fırlatır. Ancak, bu istisna updateUserDataiçindeki
launch bloğu tarafından yakalanır ve sadece bu launch coroutine'inin iptal olmasına neden olur.updateTweets coroutine'i bu durumdan etkilenmez ve "Updating..." mesajını yazdırır. Dahası, istisnamain fonksiyonunda yakalanmaz.bir istisna yakalanana kadar üst coroutine'lere doğru yayılmalıdır. Ancak,
CancellationExceptiontüretilmiş bir istisna olduğu için üst coroutine'e yayılmaz. Bu, geliştiricilerin düşebileceği
tehlikeli bir tuzaktır.
launch yerine async ve awaitkullanılsaydı,
await çağrısı UserNotFoundException fırlatırdı ve istisna olması gerektiğigibi yayılırdı.
bir çözüm, özel istisnalar türetirken
CancellationException yerine Exception veyaRuntimeException sınıflarını genişletmektir. Böylece, istisna beklenildiği gibi üstcoroutine'lere yayılır ve hata yönetimi daha öngörülebilir hale gelir.
import kotlinx.coroutines.* // Kullanıcı bulunamadığında fırlatılacak özel bir istisna - Bu daha iyi bir uygulama örneğidir class UserNotFoundException : RuntimeException() suspend fun main() { // updateUserData fonksiyonunda fırlatılacak olan istisnanın yakalandığı try-catch bloğu try { updateUserData() } catch (e: UserNotFoundException) { // İstisna yakalandığında çalışacak kod bloğu println("Kullanıcı bulunamadı") } } suspend fun updateUserData() { // Bu fonksiyon UserNotFoundException fırlatacak updateUser() // Hata burada fırlatılacak // Bu satır hiçbir zaman çalışmayacak çünkü istisna, işlemin devam etmesini engelleyecek updateTweets() // Bu çağrı çalışmayacak çünkü önceki çağrı istisna fırlatıyor } suspend fun updateTweets() { // updateUser bir istisna fırlattığı için bu fonksiyon hiçbir zaman çağrılmayacak delay(1000) println("Güncelleniyor...") } suspend fun updateUser() { // Normal bir istisna fırlatılıyor (CancellationException değil) // Bu nedenle işlem akışı kesintiye uğrar ve try-catch bloğuna yönlendirilir throw UserNotFoundException() } // Programın çıktısı - istisna yakalandığı için bu mesaj gösterilir // Kullanıcı bulunamadı
withTimeout fonksiyonunukullanabilirsiniz. Bu fonksiyon, belirtilen süre dolana kadar
coroutineScope ile aynı şekilde çalışır. Ancak, süreaşımı gerçekleştiğinde, tüm alt coroutine'lerini iptal eder ve
TimeoutCancellationException fırlatır.TimeoutCancellationException, CancellationException sınıfının bir alt türüdür ve bu nedenle, üst coroutine'lereyayılmaz, yalnızca ilgili işlem içinde kalır.
import kotlinx.coroutines.* // Belirli bir süre içinde tamamlanması gereken işlem için withTimeout kullanılıyor suspend fun test(): Int = withTimeout(1500) { // 1.5 saniye içinde tamamlanması gereken işlem başlatılıyor // İlk 1 saniyelik bekleme - bu süre sorun yaratmayacak çünkü toplam süre sınırı henüz aşılmadı delay(1000) println("Hâlâ düşünüyor") // İkinci 1 saniyelik bekleme - bu noktada toplam süre 2 saniyeye // ulaşacak ve 1.5 saniyelik sınır aşılacak delay(1000) // Burada süre aşımı yaşanacak // Bu kod çalışmayacak çünkü withTimeout zamanı aşılınca // TimeoutCancellationException fırlatacak println("Tamamlandı!") // Bu dönüş değeri de hiçbir zaman çalıştırılmayacak 42 } suspend fun main(): Unit = coroutineScope { try { // test() fonksiyonu çağrılıyor ve bu fonksiyon withTimeout ile sınırlandırılmış test() // `withTimeout` içinde çalıştırılan işlem } catch (e: TimeoutCancellationException) { // Süre aşımı gerçekleştiğinde TimeoutCancellationException fırlatılır ve burada yakalanır println("İptal edildi") // Süre aşımı gerçekleştiğinde istisna yakalanıyor } // Bu bekleme, iptal edilen test() fonksiyonunu etkilemez delay(1000) // Ekstra gecikme süresi işlemi kurtaramaz, `test` zaten iptal edildi } // Program çalıştırıldığında: // (1 saniye) // Hâlâ düşünüyor // (0.5 saniye sonra) - toplam 1.5 saniye olduğunda süre doldu ve istisna fırlatıldı // İptal edildi
withTimeout fonksiyonunun TimeoutCancellationException fırlatmasıdır.Bu istisna,
CancellationException sınıfının bir alt türüdür ve bir coroutine iptal edildiğindefırlatılan istisna ile aynıdır. Bu nedenle, bu istisna bir coroutine oluşturucusu (builder) içinde fırlatıldığında,
yalnızca ilgili coroutine iptal edilir ve üst coroutine bundan etkilenmez. Yani,
TimeoutCancellationExceptionistisnası üst coroutine'e yayılmaz.
import kotlinx.coroutines.* // Belirli bir süre içinde tamamlanması gereken işlem için withTimeout kullanılıyor suspend fun test(): Int = withTimeout(1500) { // 1.5 saniye içinde tamamlanması gereken işlem başlatılıyor // İlk 1 saniyelik bekleme - bu süre sorun yaratmayacak çünkü // toplam süre sınırı henüz aşılmadı delay(1000) println("Hâlâ düşünüyor") // İkinci 1 saniyelik bekleme - bu noktada toplam süre 2 saniyeye // ulaşacak ve 1.5 saniyelik sınır aşılacak delay(1000) // Burada süre aşımı yaşanacak // Bu kod çalışmayacak çünkü withTimeout zamanı aşılınca TimeoutCancellationException fırlatacak println("Tamamlandı!") // Bu dönüş değeri de hiçbir zaman çalıştırılmayacak 42 } suspend fun main(): Unit = coroutineScope { try { // test() fonksiyonu çağrılıyor ve bu fonksiyon withTimeout ile sınırlandırılmış test() // `withTimeout` içinde çalıştırılan işlem } catch (e: TimeoutCancellationException) { // Süre aşımı gerçekleştiğinde TimeoutCancellationException fırlatılır ve burada yakalanır println("İptal edildi") // Süre aşımı gerçekleştiğinde istisna yakalanıyor } // Bu bekleme, iptal edilen test() fonksiyonunu etkilemez delay(1000) // Ekstra gecikme süresi işlemi kurtaramaz, `test` zaten iptal edildi } // Program çalıştırıldığında: // (1 saniye) // Hâlâ düşünüyor // (0.5 saniye sonra) - toplam 1.5 saniye olduğunda süre doldu ve istisna fırlatıldı // İptal edildi
delay(1500), withTimeout(1000) tarafından belirlenen süreden daha uzun sürdüğü içinwithTimeout ilgili coroutine'i iptal eder ve TimeoutCancellationException fırlatır. Bu istisna, 1 numaralı launchbloğu tarafından yakalanır ve kendisini ve bağlı olduğu tüm alt coroutine'leri (2 numaralı
launch) iptal eder . Ancak,3 numaralı
launch bağımsız olduğu için etkilenmez ve 2 saniye sonra "Done" mesajını yazdırır. Daha az agresif biralternatif olarak,
withTimeoutOrNull fonksiyonu kullanılabilir.Bu fonksiyon süre aşımı gerçekleştiğinde istisnafırlatmaz , bunun yerine sadece bloğunu iptal eder ve
null döndürür .withTimeoutOrNull fonksiyonunu, çok uzunbekleme sürelerinin bir hata sinyali olduğu durumlarda kullanışlı buluyorum .Örneğin, ağ işlemlerinde 5 saniyeden uzun
süre bir yanıt beklemek genellikle bir soruna işaret eder (bazı kütüphaneler süresiz bekleyebilir). Bu gibi durumlarda,
withTimeoutOrNull kullanarak belirli bir süre sonunda işlemi sessizce iptal etmek mümkündür.import kotlinx.coroutines.* // Basit bir kullanıcı sınıfı class User() suspend fun fetchUser(): User { // Sonsuza kadar çalışacak bir döngü while (true) { yield() // yield() fonksiyonu, mevcut coroutine'i geçici olarak askıya alır // Böylece CPU zamanının diğer coroutine'ler tarafından kullanılabilmesini sağlar // Burada asla dönüş yapılmadığı için, bu fonksiyon sonsuza kadar çalışacaktı } } suspend fun getUserOrNull(): User? = withTimeoutOrNull(5000) { // withTimeoutOrNull, belirtilen süre içinde (5 saniye) blok tamamlanamazsa // TimeoutCancellationException fırlatmak yerine null döndürür // Bu, istisna yakalamaktan daha temiz bir yaklaşımdır fetchUser() } suspend fun main(): Unit = coroutineScope { // getUserOrNull fonksiyonu çağrılır // Bu fonksiyon içinde fetchUser() 5 saniye boyunca çalışacak ve sonra zaman aşımına uğrayacak val user = getUserOrNull() // Zaman aşımı gerçekleştiği için user değeri null olacaktır println("Kullanıcı: $user") } // Program çalıştığında: // (5 saniye sonra) - 5 saniyelik timeout süresi dolduktan sonra // Kullanıcı: null
suspendCancellableCoroutine fonksiyonunuhatırlayabilirsiniz.Bu fonksiyon,
suspendCoroutine ile benzer şekilde çalışır, ancak devam nesnesi (continuation)CancellableContinuation<T> içine sarılır.CancellableContinuation<T>, ek işlevler sunar ve bunlardan en önemlisi invokeOnCancellation fonksiyonudur. Bufonksiyon, bir coroutine iptal edildiğinde ne olacağını tanımlamak için kullanılır. Genellikle, bir kütüphanedeki
işlemleri iptal etmek veya kaynakları serbest bırakmak için kullanılır. Aşağıdaki örnekte,
suspendCancellableCoroutinekullanılarak bir iptal işlemi tanımlanmaktadır:
// İptal edilebilir bir coroutine oluşturan suspendCancellableCoroutine fonksiyonu suspend fun someTask() = suspendCancellableCoroutine { cont -> // Burada asenkron bir işlem başlatılabilir, örneğin: // - Ağ çağrısı // - Dosya işlemi // - Uzun süren hesaplama // - Veritabanı sorgusu // - Kullanıcı girdisi bekleme // İşlem tamamlandığında cont.resume(result) çağrılmalıdır // Hata durumunda cont.resumeWithException(exception) çağrılmalıdır // invokeOnCancellation, coroutine iptal edildiğinde çalıştırılacak kod bloğunu tanımlar cont.invokeOnCancellation { throwable -> // Bu blok, coroutine iptal edildiğinde çalışır // Burada yapılabilecek temizleme işlemleri: // - Açık kaynakları kapatma (dosyalar, soketler, veritabanı bağlantıları) // - Devam eden işlemleri iptal etme (HTTP istekleri gibi) // - Thread'leri durdurma // - Geçici dosyaları silme // - İptal nedeni hakkında loglama (throwable parametresi kullanılarak) } }
CancellableContinuation<T>, job durumunu kontrol etmemizi sağlar. isActive, isCompleted ve isCancelledözellikleri kullanılarak coroutine'in durumu sorgulanabilir. Ayrıca, devam nesnesini (continuation) belirli bir iptal
nedeni ile sonlandırmak için
cancel fonksiyonu kullanılabilir.yüzden nasıl çalıştığını iyi anlamak önemlidir. Bu bölümden hatırlamanız gerekenler:
- Bir coroutine iptal edildiğinde, durumu "Cancelling" olarak değişir ve tüm alt coroutine'leri iptal edilir.
-
"Cancelling" durumundaki bir coroutine, yeni alt coroutine başlatmaz ve askıya alınmak istendiğinde
veya askıya alınmış durumdaysaCancellationExceptionfırlatır. -
finallybloğu veinvokeOnCompletionişleyicisinin her zaman çalıştırılacağı garanti edilir. -
CancellationExceptionyakalayarak iptal durumunda özel bir işlem gerçekleştirebiliriz, ancak bu istisna
dış kapsama iletilmelidir. -
"Cancelling" durumundayken yeni bir coroutine başlatmak veya askıya alınabilir bir çağrı yapmak için
withContext(NonCancellable)kullanılabilir. -
Askıya alınmayan işlemler arasında iptale izin vermek için
yieldveyaensureActivekullanılabilir.
CancellationExceptionüst coroutine'e yayılmaz. -
Bir coroutine’i belirli bir süre sınırıyla başlatmak için
withTimeoutveyawithTimeoutOrNullkullanılabilir. -
Geri çağrılı (callback-based) API’leri askıya alınabilir fonksiyonlara dönüştürmek için daima
suspendCancellableCoroutinekullanılmalı ve iptal durumunda yapılması gereken işlemlerinvokeOnCancellation
içinde tanımlanmalıdır.
performansını doğrudan etkileyen önemli bir faktördür. Bu avantajlardan en iyi şekilde yararlanmanızı umuyorum.
- 1.Android'deki
CoroutineWorkerbuna iyi bir örnektir. Google'da Android üzerine çalışan ↩ - 2.Aslında, iptal mekanizmasının sağladığı avantajlar çok daha değerlidir. ↩
- 3.Bu fonksiyon, önce
cancelçağırarak coroutine'i iptal eder, ardındanjoin↩ - 4.Eğer bu parametre
trueolarak ayarlanırsa, ilgili fonksiyon "Cancelling" ↩ - 5.Bu parametre, bir coroutine zaten istenen durumda olduğunda, belirtilen işleyicinin ↩