
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
anlamak zorundadır. Ben de onlardan biriyim, bu yüzden coroutine mekanizmasının nasıl çalıştığını öğrenmek istedim. Eğer
sen de böyle biriysen, bu bölümü okumaktan keyif alacaksın. Eğer ilgini çekmiyorsa, bu bölümü atlayabilirsin.
nasıl işlediğini teknik düzeyde ele almayı amaçlamaktadır. Temel noktalar şunlardır:
- Askıya alınan fonksiyonlar, birer durum makinesi gibi çalışır. Fonksiyonun başlangıç noktası ve her askıya alınan
fonksiyon çağrısından sonra belirli bir durumu vardır. - Askıya alınan bir fonksiyon çağrılmadan önce, yürütme durumu ile yerel değişkenlerin referansları, bir devam
nesnesinde (continuation object) saklanır. - Bir fonksiyonun devam nesnesi, onu çağıran fonksiyonun devam nesnesini sarmalar. Bu nedenle, tüm devam nesneleri
birlikte bir çağrı yığını oluşturur ve bu yapı, fonksiyon devam ettirildiğinde veya tamamlandığında yürütme sırasını
belirler. - Askıya alınan bir fonksiyon devam ettirildiğinde, öncelikle kendi iç işlemlerini yürütür. Daha sonra, onu çağıran
fonksiyonun devam nesnesi çalıştırılır. Bu işlem, yığının en üstüne ulaşana kadar devam eder.
Eğer ilgini çekmiyorsa, bu bölümü atlayabilirsin.
devam nesnesi geçişli programlama (continuation-passing style)* olarak adlandırılan yöntemi tercih etmiştir. Bu
yöntemde, bir fonksiyonun yürütme durumu devam nesneleri aracılığıyla korunur ve bir fonksiyondan diğerine argüman
olarak iletilir.
Kotlin’de, bu nesneler geleneksel olarak bir fonksiyonun son parametresi olarak yerleştirilir.
suspend fun getUser(): User? // Askıya alınabilir bir fonksiyondur. // Kullanıcıyı getirir, sonucu null olabilir. // Coroutine tarafından çağrıldığında duraklatılabilir yapıdadır. suspend fun setUser(user: User) // Kullanıcı bilgisini kaydeden askıya alınabilir bir işlemdir. // Normal bir fonksiyon gibi görünse de coroutine içinde çalıştırılırsa askıya alınabilir. suspend fun checkAvailability(flight: Flight): Boolean // Bir uçuşun uygun olup olmadığını kontrol eden askıya alınabilir fonksiyondur. // Boolean değer döner, ama coroutine içinde durdurulup sonra devam ettirilebilir. // Derleyici tarafından dönüştürülmüş hali fun getUser(continuation: Continuation<*>): Any? // Derleyici, suspend fonksiyonlara otomatik olarak bir Continuation parametresi ekler. // Bu continuation, coroutine’in kaldığı yeri, bağlamı ve devam ettirilmesini yönetir. // Fonksiyonun dönüş türü artık Any? olur: // - Ya User nesnesi döner, // - Ya coroutine askıya alınmışsa özel bir COROUTINE_SUSPENDED işareti döner. fun setUser(user: User, continuation: Continuation<*>): Any // Normalde Unit dönen fonksiyon da Any tipine dönüştürülür. // Çünkü coroutine anlık olarak devam edebilir ya da durdurulmuş olabilir. // Bu yapı sayesinde derleyici coroutine state-machine (durum makinesi) oluşturabilir. fun checkAvailability(flight: Flight, continuation: Continuation<*>): Any // Aynı dönüşüm burada da geçerli: Boolean yerine artık Any döner. // Geriye Boolean dönebilir veya coroutine askıya alındıysa özel bir sinyal dönebilir. // JVM, bu yapılarla coroutine akışını manuel olarak kontrol eder.
etmiş olabilirsin. Bunun nedeni, askıya alınan bir fonksiyonun yürütülmesi sırasında iki farklı senaryonun
gerçekleşebilmesidir: Fonksiyon tamamlanırsa belirtilen dönüş türündeki değeri döndürür, ancak askıya alınırsa herhangi
bir değer döndürmek yerine özel bir belirteç olan
COROUTINE_SUSPENDED değerini döndürür. Örneğin,suspend fun getUser(): User? fonksiyonu derleyici tarafından fun getUser(continuation: Continuation<*>): Any?şeklinde dönüştürülür. Burada dönüş türü
User? yerine Any? olarak değiştirilmiştir, çünkü getUser fonksiyonu yaUser? türünde bir değer döndürebilir ya da askıya alındığında COROUTINE_SUSPENDED döndürebilir.COROUTINE_SUSPENDED nesnesi Any türüne sahip olduğu için, Kotlin’in tür sisteminde User? ve COROUTINE_SUSPENDEDiçin ortak bir üst tür gereklidir. Kotlin henüz birleşim türlerini (union types) desteklemediğinden, derleyici bu iki
farklı dönüş değerini kapsayacak en geniş tür olarak
Any? seçmektedir. Eğer gelecekte Kotlin birleşim türlerinidesteklerse, dönüş türü
User? | COROUTINE_SUSPENDED şeklinde ifade edilebilir, ancak şu an için dönüş türü Any?olarak genelleştirilmektedir.
basit bir fonksiyonla başlayalım.
suspend fun myFunction() { println("Öncesi") // Fonksiyon çalışmaya başlar, bu satır hemen yazdırılır. delay(1000) // askıya alma işlemi // Bu noktada coroutine askıya alınır. // delay fonksiyonu suspend olduğu için coroutine burada durur. // 1000 ms sonra coroutine tekrar devam ettirilir. println("Sonrası") // Gecikme tamamlandıktan sonra coroutine kaldığı yerden devam eder ve bu satır yazdırılır. }
myFunction fonksiyonunun derleyici tarafından nasıl dönüştürüldüğünü şimdiden tahmin edebilirsin.fun myFunction(continuation: Continuation<*>): Any // Bu, Kotlin derleyicisinin bir `suspend` fonksiyonu dönüştürdüğü JVM biçimidir. // Orijinal hali şuydu: // suspend fun myFunction() // Derleyici bu fonksiyonu aşağıdaki gibi dönüştürür: // 1. Fonksiyona ekstra bir parametre (Continuation<*>) eklenir. // 2. Dönüş tipi `Unit` olsa bile artık `Any` olur, çünkü: // - Fonksiyon normal şekilde tamamlanırsa → Unit döner. // - Eğer askıya alınırsa → özel bir COROUTINE_SUSPENDED nesnesi döner. // Bu dönüşüm sayesinde coroutine durdurulabilir, devam ettirilebilir ve tüm kontrol akışı yönetilebilir.
açıklamayı kolaylaştırmak için
MyFunctionContinuation olarak adlandıralım (gerçekte bu nesne, anonim bir nesne ifadesiolarak oluşturulur ve doğrudan bir adı olmaz).
myFunction fonksiyonu aldığı continuation parametresini, kendi devam nesnesi (MyFunctionContinuation) ile sarar. Bu işlem, askıya alınan fonksiyonun hangi durumda olduğunu hatırlamasını sağlar veaskıya alındığı noktadan devam edebilmesine olanak tanır.
val continuation = MyFunctionContinuation(continuation) // Bu satır, verilen continuation nesnesini, bu fonksiyona özel bir "state machine" sınıfına (MyFunctionContinuation) sarar. // Bu sarma işlemi sayesinde, coroutine'in her suspend noktasındaki ilerleyişi kontrol edilebilir hale gelir. // continuation burada tip olarak genelde Continuation<Any?> olur ve özel mantık barındırmaz.
fonksiyonun devam ettirilme (resume) sürecinin bir parçasıdır ve bu durumda mevcut devam nesnesi olduğu gibi
korunmalıdır1Buradaki mekanizma aslında biraz daha karmaşıktır, çünkü
labelın ilk biti de değiştirilir ve bu değişiklik.anlayacaksın. Özetle, ilk kez çağrıldığında devam nesnesi sarılır, ancak bir askıya alma işleminden sonra devam
ettirilirken mevcut nesne korunur.
val continuation = if (continuation is MyFunctionContinuation) continuation else MyFunctionContinuation(continuation) // Bu kontrol coroutine’in ilk kez mi çalıştırıldığını yoksa daha önce askıya alınıp şimdi devam mı ettirildiğini belirler. // Eğer `continuation`, `MyFunctionContinuation` türündeyse bu coroutine zaten sarılmıştır → doğrudan kullanılır. // Değilse (ilk kez çağrılıyorsa) → yeni bir `MyFunctionContinuation` oluşturularak coroutine durum makinesi başlatılır.
val continuation = continuation as? MyFunctionContinuation ?: MyFunctionContinuation(continuation) // continuation nesnesi, eğer zaten MyFunctionContinuation tipindeyse olduğu gibi kullanılır. // Bu durumda coroutine daha önce başlatılmış ve şu an devam ettiriliyor demektir. // Eğer değilse (ilk kez çağrılıyorsa), yeni bir MyFunctionContinuation nesnesi oluşturularak coroutine sarılır. // Bu yapı coroutine’in durumunu (state) takip etmek için kullanılan durum makinesini (state machine) hazırlar.
suspend fun myFunction() { println("Öncesi") // Bu satır coroutine çalışmaya başladığında hemen yazdırılır. delay(1000) // askıya alma işlemi // Bu satırda coroutine askıya alınır. // delay fonksiyonu bir süre bekler, ancak thread bloke edilmez. // Bu sırada coroutine durdurulur, continuation nesnesi ile kaldığı yer saklanır. // 1 saniye sonra coroutine yeniden başlatılır ve devam eder. println("Sonrası") // 1 saniyelik gecikmeden sonra coroutine tekrar başlatılır ve bu satır yazdırılır. }
suspend fonksiyon iki farklı noktadan başlatılabilir:- İlk çağrıldığında, yani fonksiyon daha önce hiç çalıştırılmamışsa baştan başlar.
- Daha önce askıya alınmışsa (suspend edilmişse), devam nesnesi (continuation) sayesinde askıya alındığı yerden devam
eder.
label)kullanılır.
- Fonksiyonun ilk kez çağrıldığında,
labeldeğeri0olarak ayarlanır. Bu, fonksiyonun baştan başlaması gerektiği
anlamına gelir. - Fonksiyon askıya alınmadan önce,
labeldeğeri bir sonraki durumu gösterecek şekilde güncellenir. - Böylece, devam nesnesi (continuation) ile tekrar çalıştırıldığında, fonksiyon doğrudan askıya alındığı noktadan devam
eder.
// myFunction fonksiyonunun perde arkasındaki basitleştirilmiş hali fun myFunction(continuation: Continuation<Unit>): Any { val continuation = continuation as? MyFunctionContinuation ?: MyFunctionContinuation(continuation) // continuation nesnesi eğer daha önce özel olarak sarılmışsa (MyFunctionContinuation), doğrudan kullanılır. // Eğer ham bir continuation gelmişse, yeni bir state-machine sarmalayıcısı ile sarılır. // Bu sarma işlemi coroutine’in ilerleyiş durumunu izlemek için gereklidir. if (continuation.label == 0) { println("Öncesi") continuation.label = 1 if (delay(1000, continuation) == COROUTINE_SUSPENDED) { return COROUTINE_SUSPENDED } } // Eğer coroutine ilk kez çalışıyorsa (label == 0), // "Öncesi" yazdırılır ve label değeri 1 olarak güncellenir (yani bir sonraki adım işaretlenir). // Ardından delay(1000, continuation) çağrılır. // Bu çağrı coroutine’in askıya alınmasına sebep olabilir. // Askıya alınırsa COROUTINE_SUSPENDED döndürülür ve fonksiyon burada durur. if (continuation.label == 1) { println("Sonrası") return Unit } // Coroutine yeniden başlatıldığında (label == 1), // bu blok çalışır ve "Sonrası" yazdırılır. // Fonksiyon başarıyla tamamlanır ve Unit döner. error("İmkansız") } // label ne 0 ne de 1 ise bu noktaya ulaşılır ki bu, normal şartlarda mümkün değildir. // Bu satır genellikle coroutine durumunun bozulduğu (bir bug olduğu) anlamına gelir.
delay fonksiyonu askıya alındığında COROUTINE_SUSPENDEDdeğerini döndürür, ardından
myFunction fonksiyonu da COROUTINE_SUSPENDED döndürür; aynı işlem, bu fonksiyonu çağıranfonksiyon tarafından da yapılır ve çağrı yığınının en üstüne kadar tüm fonksiyonlar için aynı süreç gerçekleşir2Daha somut bir ifadeyle,
COROUTINE_SUSPENDED değeri, ya builder fonksiyonuna ya da resume fonksiyonuna.Bu mekanizma, askıya alma işleminin tüm çağrıları sonlandırmasını ve mevcut iş parçacığını (thread) diğer
çalıştırılabilir görevler (runnable) için kullanılabilir hale getirmesini sağlar. Böylece, iş parçacığı başka
coroutine’ler veya görevler tarafından kullanılabilir.
delay çağrısı COROUTINE_SUSPENDED döndürmeseydi ne olurdu?Eğer doğrudan
Unit döndürseydi (gerçekte böyle olmayacağını biliyoruz, ancak varsayımsal olarak düşünelim), bu durumdafonksiyon sadece bir sonraki duruma geçer ve herhangi bir askıya alma gerçekleşmeden sıradan bir fonksiyon gibi
çalışmaya devam ederdi.
hali aşağıdaki gibidir:
cont = object : ContinuationImpl(continuation) { // continuation: coroutine'in devamını yönetecek üst nesne // ContinuationImpl: Kotlin stdlib içinde coroutine'lerin durum makinesini çalıştırmak için kullanılan temel sınıf var result: Any? = null // Coroutine askıya alınıp devam ettirildiğinde dışarıdan gelen sonucu saklar var label = 0 // Coroutine'in hangi adımda olduğunu belirtir (0: başlangıç, 1: sonraki adım...) // Derleyici her suspend noktasında bu label'ı artırarak adım kontrolü yapar override fun invokeSuspend(`$result$: Any?): Any? { this.result = $result` // Coroutine dışarıdan yeniden çalıştırıldığında gelen sonucu kaydeder // (resume veya resumeWithException ile verilmiş olabilir) return myFunction(this) // Coroutine’in gövdesi olan myFunction fonksiyonu çağrılır // Bu fonksiyon içinde label kontrolü yapılır ve kaldığı yerden devam eder } }
MyFunctionContinuation adlı bir sınıf olarak temsil etmeye kararverdim. Ayrıca,
ContinuationImpl gövdesini satır içi (inline) hale getirerek kalıtımı gizlemeyi tercih ettim. Ortayaçıkan sınıf basitleştirilmiş bir versiyondur; gereksiz optimizasyonları ve ek işlevleri kaldırarak yalnızca temel
unsurları korudum.
JVM’de, tür parametreleri derleme sırasında silinir. Örneğin,Continuation<Unit>veContinuation<String>
derlendikten sonra yalnızcaContinuationolarak kalır. Burada gösterdiğimiz her şey JVM bayt kodunun Kotlin’deki
temsili olduğundan, bu tür parametreleri dikkate almana gerek yoktur.
import java.util.concurrent.Executors import java.util.concurrent.TimeUnit import kotlin.coroutines.Continuation import kotlin.coroutines.CoroutineContext import kotlin.coroutines.EmptyCoroutineContext import kotlin.coroutines.resume // Örnek Başlangıcı fun myFunction(continuation: Continuation<Unit>): Any { val continuation = continuation as? MyFunctionContinuation ?: MyFunctionContinuation(continuation) // Eğer coroutine daha önce başlatıldıysa mevcut continuation kullanılır. // Değilse coroutine kontrolü için yeni bir MyFunctionContinuation oluşturulur. if (continuation.label == 0) { println("Öncesi") // Coroutine ilk çalıştırıldığında bu satır yazdırılır. continuation.label = 1 // Coroutine’in bir sonraki adıma geçtiği işaretlenir. if (delay(1000, continuation) == COROUTINE_SUSPENDED) { return COROUTINE_SUSPENDED // delay çağrısı coroutine’i askıya alırsa, özel bir işaret döner. } } if (continuation.label == 1) { println("Sonrası") // Coroutine yeniden başlatıldığında bu adım çalışır. return Unit // Fonksiyon tamamlanır. } error("İmkansız") // Coroutine beklenmeyen bir durumda çağrılmışsa hata fırlatılır. } class MyFunctionContinuation( val completion: Continuation<Unit> ) : Continuation<Unit> { override val context: CoroutineContext get() = completion.context // Coroutine context'i üst continuation'dan alınır. var label = 0 // Hangi adımda (state) olduğunu tutan değişken. var result: Result<Any>? = null // suspend fonksiyondan dönecek olan sonucu geçici olarak saklar. override fun resumeWith(result: Result<Unit>) { this.result = result // Dışarıdan coroutine’e iletilen sonucu saklar. val res = try { val r = myFunction(this) // Coroutine fonksiyonunun gövdesi çalıştırılır. // Bu çağrı coroutine’in kaldığı yerden devam etmesini sağlar. if (r == COROUTINE_SUSPENDED) return // Askıya alınmışsa burada durulur, devam daha sonra yapılır. Result.success(r as Unit) // Aksi halde coroutine başarıyla sonuçlandı demektir. } catch (e: Throwable) { Result.failure(e) // Coroutine çalışması sırasında hata oluşursa yakalanır. } completion.resumeWith(res) // Sonuç orijinal üst continuation’a aktarılır (örneğin main coroutine). } } private val executor = Executors .newSingleThreadScheduledExecutor { Thread(it, "scheduler").apply { isDaemon = true } } // Coroutine askıya alındığında devam ettirilmek üzere planlama yapan bir zamanlayıcı (scheduler) oluşturulur. // Bu thread daemon (arka plan) olduğu için programın kapanmasını engellemez. fun delay(timeMillis: Long, continuation: Continuation<Unit>): Any { executor.schedule({ continuation.resume(Unit) }, timeMillis, TimeUnit.MILLISECONDS) // Belirtilen süre dolduktan sonra continuation yeniden çalıştırılır. return COROUTINE_SUSPENDED // delay fonksiyonu çalışırken coroutine askıya alınmış olur. } fun main() { val EMPTY_CONTINUATION = object : Continuation<Unit> { override val context: CoroutineContext = EmptyCoroutineContext // Basit bir context, burada hiçbir özel yapı yoktur. override fun resumeWith(result: Result<Unit>) { // Bu örnek için resumeWith boştur; coroutine tamamlandığında yapılacak bir işlem yok. } } myFunction(EMPTY_CONTINUATION) // Coroutine başlatılır. Thread.sleep(2000) // Ana thread’in hemen bitmesini engellemek için bekleme süresi eklenmiştir. } val COROUTINE_SUSPENDED = Any() // Coroutine’in askıya alındığını belirten özel işaret nesnesidir. // Kotlin’in derleyici altyapısı tarafından kontrol edilir. //Örnek Sonu
ilgili fonksiyonu aç ve şu adımları takip et:
- Menüden şu yolu izle:
Tools > Kotlin > Show Kotlin Bytecode - Açılan ekranda "Decompile" düğmesine tıkla.
yazılmış olsaydı nasıl görüneceğini inceleyebilirsin.

Dosyadan üretilen bayt kodunu gösterme yöntemi.

Dosyadan üretilen bayt kodu. "Decompile" düğmesine dikkat et, bu düğme bayt kodunu Java'ya decompile etmeyi sağlar.

Kotlin'deki askıya alınan fonksiyonun Java'ya decompile edilmiş bayt kodu.
parametreler gibi durum bilgilerini de geri yüklemesi gerekir. Peki, eğer fonksiyon içinde askıya alma işleminden
önce tanımlanan ve sonrasında kullanılan bir yerel değişken eklersek ne olur3Aynı durum (state) içinde tanımlanan ve kullanılan bir yerel değişken, devam nesnesinde saklanmak zorunda?
ettirildiğinde geri yüklenmesi gerekir.
suspend fun myFunction(soyadı: String) { println("Öncesi") // Coroutine başladığında bu satır hemen çalışır. var ad = "John" // Coroutine içinde kullanılan lokal bir değişken tanımlanır. delay(1000) // askıya alınıyor // Bu noktada coroutine askıya alınır. // delay fonksiyonu nedeniyle coroutine durur ama thread bloke edilmez. // Coroutine askıya alındığında `Continuation` nesnesi ile durduğu yer kaydedilir. println("Adı: $ad $soyadı") // Coroutine devam ettiğinde, kaldığı yerden yürütme devam eder. // Burada adı ve soyadı birlikte yazdırılır. println("Sonrası") // Coroutine’in en son adımıdır; işlem başarıyla tamamlanır. }
name değişkeni iki farklı durumda gereklidir (label = 0 ve label = 1 için), bu yüzden devam nesnesinde (continuation) saklanması gerekir. Askıya alınmadan hemen önce saklanır ve fonksiyon devam ettirildiğinde geri yüklenir.
alındığı için, devam nesnesi oluşturulduğunda otomatik olarak saklanır ve fonksiyon devam ettirildiğinde doğrudan
kullanılabilir.
import java.util.concurrent.Executors import java.util.concurrent.TimeUnit import kotlin.coroutines.* // Örnek Başlangıcı fun myFunction(soyadı: String, continuation: Continuation<Unit>): Any { val continuation = continuation as? MyFunctionContinuation ?: MyFunctionContinuation(soyadı, continuation) // continuation nesnesi daha önce coroutine tarafından sarılmış mı kontrol edilir. // Eğer değilse, yeni bir MyFunctionContinuation nesnesi oluşturularak sarılır. var ad = continuation.name // Coroutine'in askıya alınmadan önceki ad değişkeni (name) varsa geri alınır. if (continuation.label == 0) { println("Öncesi") // Coroutine ilk kez çalıştırıldığında bu satır yazdırılır. ad = "John" // Lokal değişkene bir değer atanır. continuation.name = ad // Bu değer state-machine'e (continuation nesnesine) kaydedilir. continuation.label = 1 // Coroutine bir sonraki adıma geçtiği için label güncellenir. if (delay(1000, continuation) == COROUTINE_SUSPENDED) { return COROUTINE_SUSPENDED // delay fonksiyonu askıya alınma noktasıdır. Coroutine durur, daha sonra devam ettirilir. } } if (continuation.label == 1) { println("Adı: $ad $soyadı") // Coroutine devam ettirildiğinde bu satır çalışır. Değişkenler kaldığı yerden devam eder. println("Sonrası") // Coroutine’in son satırı yazdırılır. return Unit // Coroutine başarıyla tamamlanır. } error("İmkansız") // Coroutine tanımsız bir label ile karşılaşırsa bu satıra düşer, bu mantıksal bir hatadır. } class MyFunctionContinuation( val soyadı: String, val completion: Continuation<Unit> ) : Continuation<Unit> { override val context: CoroutineContext get() = completion.context // continuation context bilgisi üst coroutine'den miras alınır. var result: Result<Unit>? = null // Sonuç objesi burada saklanır, exception ya da success olabilir. var label = 0 // Coroutine’in hangi adımda olduğunu gösteren state bilgisi. var name: String? = null // askıya alınmadan önceki ad (isim) bilgisini saklar. override fun resumeWith(result: Result<Unit>) { this.result = result // dışarıdan coroutine'e verilen sonucu saklar val res = try { val r = myFunction(soyadı, this) // Coroutine gövdesi yeniden çalıştırılır. if (r == COROUTINE_SUSPENDED) return // Askıya alınmışsa hiçbir şey yapılmaz, sadece beklenir. Result.success(r as Unit) // Coroutine başarıyla tamamlandıysa bu sonuç üst continuation’a iletilecek. } catch (e: Throwable) { Result.failure(e) // Coroutine çalışırken hata oluşursa buraya düşer. } completion.resumeWith(res) // Üst coroutine (örn. main) resumeWith ile son sonucu alır. } } private val executor = Executors.newSingleThreadScheduledExecutor { Thread(it, "zamanlayıcı").apply { isDaemon = true } } // Coroutine askıya alındığında belirli süre sonra yeniden çalıştırmak için kullanılan zamanlayıcı (scheduler). // Tek bir daemon thread kullanır, yani JVM kapanmasını engellemez. fun delay(süreMs: Long, devamNesnesi: Continuation<Unit>): Any { executor.schedule({ devamNesnesi.resume(Unit) }, süreMs, TimeUnit.MILLISECONDS) // Belirtilen süre geçtikten sonra coroutine yeniden başlatılır (resume). return COROUTINE_SUSPENDED // delay fonksiyonu coroutine’in askıya alındığını bildirir. } fun main() { val EMPTY_CONTINUATION = object : Continuation<Unit> { override val context: CoroutineContext = EmptyCoroutineContext // Bu örnekte özel bir coroutine context yok, boş context kullanılıyor. override fun resumeWith(result: Result<Unit>) { // Coroutine tamamlandığında çalışacak yer. // Bu örnekte bir işlem yapılmıyor çünkü kök coroutine burası. } } myFunction("Doe", EMPTY_CONTINUATION) // Coroutine başlatılır. "Doe" soyadı parametresi verilir. Thread.sleep(2000) // delay işlemi tamamlanmadan main thread’in bitmesini engellemek için bekleme süresi eklenmiştir. } private val COROUTINE_SUSPENDED = Any() // Coroutine’in askıya alındığını belirtmek için kullanılan özel bir nesnedir. // Kotlin derleyicisi coroutine’in durup durmadığını anlamak için bu nesneyi kontrol eder. // Örnek Sonu
Devam nesnelerinin (continuation) yalnızca mevcut nesnelere referans verdiğini unutma; bunları kopyalamazlar. Bu işlem
oldukça hafiftir. Askıya alınan bir fonksiyonun çağrılmasındaki en büyük maliyet, devam nesnesinin oluşturulmasıdır.
Bu nesne hafif bir yapıdır, ancak yine de bir nesnedir.
suspend fun printUser(token: String) { println("Before") // Fonksiyon başladığında bu satır hemen yazdırılır. val userId = getUserId(token) // Token üzerinden kullanıcı ID'si alınır. // Bu işlem askıya alınabilir bir suspend fonksiyon çağrısıdır. println("User ID received: $userId") // Kullanıcı ID'si alındıktan sonra ekrana yazdırılır. val userName = getUserName(userId, token) // Kullanıcı adı, kullanıcı ID'si ve token kullanılarak alınır. // Bu da askıya alınabilir bir işlemdir. println(User(userId, userName)) // Alınan bilgilerle User nesnesi oluşturulur ve ekrana yazdırılır. println("After") // Coroutine tamamlandığında bu satır yazdırılır. }
getUserId ve getUserName. Ayrıca, fonksiyona tokenadlı bir parametre eklenmiş ve bu askıya alınan fonksiyon bazı değerler döndürmektedir. Bu nedenle, bu bilgilerin devam
nesnesinde (continuation) saklanması gerekir:
token, çünkügetUserNamefonksiyonunu çağırmak için gereklidir.userId, çünkü birinci ve ikinci durumlardaki yürütme sürecinde gereklidir.result,Resulttüründe olup, fonksiyonun nasıl devam ettirildiğini gösterir.
result, Result.Success(value) olur. Bu durumda, döndürülen değeralınarak kullanılır.
result, Result.Failure(exception) olur. Bu durumda,istisna fırlatılır.
tanır.
import java.util.concurrent.Executors import java.util.concurrent.TimeUnit import kotlin.coroutines.* // Örnek Başlangıcı // Example Start fun printUser( token: String, continuation: Continuation<*> ): Any { val continuation = continuation as? PrintUserContinuation ?: PrintUserContinuation( continuation as Continuation<Unit>, token ) // Eğer continuation daha önce sarmalanmışsa yeniden sarılmaz. // İlk defa girildiyse yeni bir PrintUserContinuation oluşturulur. var result: Result<Any>? = continuation.result var userId: String? = continuation.userId val userName: String // Suspend çağrılardan dönecek ara sonuçlar burada saklanır. if (continuation.label == 0) { println("Before") // Coroutine başlatıldığında ilk çalışan satır. continuation.label = 1 val res = getUserId(token, continuation) // getUserId suspend fonksiyonu çağrılır. if (res == COROUTINE_SUSPENDED) { return COROUTINE_SUSPENDED // Eğer işlem askıya alındıysa burada durulur. } result = Result.success(res) // Askıya alınmadıysa sonuç alınır. } if (continuation.label == 1) { userId = result!!.getOrThrow() as String println("User ID received: $userId") // İlk suspend çağrıdan dönen ID alınır ve yazdırılır. continuation.label = 2 continuation.userId = userId // Bu bilgi bir sonraki adımda kullanılmak üzere saklanır. val res = getUserName(userId, continuation) // getUserName suspend fonksiyonu çağrılır. if (res == COROUTINE_SUSPENDED) { return COROUTINE_SUSPENDED // Askıya alındıysa burada durulur. } result = Result.success(res) // Askıya alınmadıysa sonuç alınır. } if (continuation.label == 2) { userName = result!!.getOrThrow() as String println(User(userId as String, userName)) // İkinci suspend çağrıdan dönen kullanıcı adı alınır ve yazdırılır. println("After") // Coroutine tamamlandığında son satır yazdırılır. return Unit // Coroutine başarıyla tamamlandıysa Unit döner. } error("Unreachable state") // Geçersiz bir state varsa hata fırlatılır. } class PrintUserContinuation( val completion: Continuation<Unit>, val token: String ) : Continuation<String> { override val context: CoroutineContext get() = completion.context // Coroutine context üst continuation'dan alınır. var label = 0 var result: Result<Any>? = null var userId: String? = null // Suspend fonksiyonlar arasında veri taşımak için alanlar. override fun resumeWith(result: Result<String>) { this.result = result // Sonuç saklanır (başarı ya da hata olabilir). val res = try { val r = printUser(token, this) // Coroutine tekrar çağrılır, kaldığı yerden devam eder. if (r == COROUTINE_SUSPENDED) return Result.success(r as Unit) // Eğer askıya alınmadıysa başarıyla tamamlandı varsayılır. } catch (e: Throwable) { Result.failure(e) // Coroutine çalışırken istisna fırlatıldıysa buraya düşer. } completion.resumeWith(res) // Üst coroutine’e sonucu bildirir. } } fun main() { toStart() // Başlatma fonksiyonu çağrılır. } private val executor = Executors.newSingleThreadScheduledExecutor { Thread(it, "scheduler").apply { isDaemon = true } } // Arka planda çalışan bir zamanlayıcı (daemon thread). // Bu sayede gecikme ile yapılacak işlemler gerçekleştirilebilir. data class User(val id: String, val name: String) // Kullanıcıyı temsil eden basit veri sınıfı.object ApiException : Throwable("Sahte API istisnası") object ApiException : Throwable("Fake API exception") // API çağrılarında hata simülasyonu için oluşturulmuş sahte istisna. fun getUserId(token: String, continuation: Continuation<String>): Any { executor.schedule({ continuation.resume("someId") }, 1000, TimeUnit.MILLISECONDS) // 1 saniye sonra "someId" sonucu ile coroutine devam ettirilir. return COROUTINE_SUSPENDED // Bu işlem askıya alındı, coroutine burada durur. } fun getUserName(userId: String, continuation: Continuation<String>): Any { executor.schedule({ continuation.resume("someName") // Hata üretmek istenirse aşağıdaki satır kullanılabilir: // continuation.resumeWithException(ApiException) }, 1000, TimeUnit.MILLISECONDS) return COROUTINE_SUSPENDED // Coroutine yine askıya alınır. } fun toStart() { val EMPTY_CONTINUATION = object : Continuation<Unit> { override val context: CoroutineContext = EmptyCoroutineContext // Coroutine context boş tanımlanmıştır. override fun resumeWith(result: kotlin.Result<Unit>) { if (result.isFailure) { result.exceptionOrNull()?.printStackTrace() // Eğer coroutine bir hata ile biterse stack trace yazdırılır. } } } printUser("someToken", EMPTY_CONTINUATION) // printUser coroutine'i başlatılır. Thread.sleep(3000) // Arka plandaki işlemler tamamlanmadan main thread'in bitmesini engellemek için bekleme eklenir. } private fun Result<*>.throwOnFailure() { if (isFailure) throw exceptionOrNull()!! } // Eğer Result başarısızsa içindeki exception fırlatılır. // Kotlin derleyicisinin internal olarak kullandığı yardımcı fonksiyonlardan biridir. private val COROUTINE_SUSPENDED = Any() // Coroutine’in askıya alındığını belirten özel sabittir. // Derleyici veya runtime, bu değeri coroutine'in devam edip etmeyeceğini anlamak için kullanır. // Örnek Sonu
a fonksiyonu b fonksiyonunu çağırdığında, sanal makinenin a fonksiyonunun durumunu ve b tamamlandığındayürütmenin nereye döneceğini saklaması gerekir. Bu bilgiler çağrı yığını (call stack) adı verilen bir yapıda
tutulur4Çağrı yığınının (call stack) kullanılabilir alanı sınırlıdır. Bu alan tamamen kullanıldığında.
temizlenir. Bu nedenle, askıya alınan bir fonksiyon devam ettirildiğinde çağrı yığını artık kullanışlı değildir .
Bunun yerine, devam nesneleri (continuations) çağrı yığınının yerini alır .
- Fonksiyonun askıya alındığı noktayı (
label) saklar. - Fonksiyonun yerel değişkenlerini ve parametrelerini alanlar (fields) içinde saklar.
- Fonksiyonu çağıran fonksiyonun devam nesnesine referans tutar.
çalışır, ancak askıya alındığında temizlenmek yerine nesne referansları üzerinden korunur. Bu mekanizma, çağrı
yığınının işlevlerini sürdürmek için kullanılır.
suspend fun a() { val user = readUser() // readUser suspend fonksiyonudur, bir yerden kullanıcı bilgisini (örneğin disk veya ağdan) okur. // Coroutine burada askıya alınabilir. b() // b() fonksiyonu çağrılır; 10 kez c() fonksiyonunu çağıracaktır. b() // İkinci kez aynı işlemi tekrar yapar. b() // Üçüncü kez tekrar eder. println(user) // İlk başta alınan user bilgisi ekrana yazdırılır. } suspend fun b() { for (i in 1..10) { c(i) // Her bir döngü adımı için c(i) çağrılır. // Bu da gecikmeli bir işlem olduğu için coroutine askıya alınabilir. } // Toplamda 10 kez c() çağrılır; delay süreleri artan şekilde ilerler. } suspend fun c(i: Int) { delay(i * 100L) // i değeriyle orantılı olarak gecikme uygulanır. // Örneğin i=1 için 100ms, i=2 için 200ms… i=10 için 1000ms. println("Tick") // Gecikme tamamlandıktan sonra "Tick" yazdırılır. }
CContinuation( i = 4, label = 1, completion = BContinuation( i = 4, label = 1, completion = AContinuation( label = 2, user = User@1234, completion = ... ) ) ) // Bu yapı coroutine zincirini temsil eder. // CContinuation: // En içteki aktif coroutine durumudur. // Şu anda c(i) fonksiyonunda çalışıyoruz (i = 4). // label = 1 → c() fonksiyonunda delay() çağrısı geçmiş, şimdi println("Tick") kısmına geçiyor. // BContinuation: // b() fonksiyonunun durumu burada tutulur. // i = 4 → b() fonksiyonu for döngüsünde 4. adımdadır. // label = 1 → c(i) çağrıldı ve sonucunun dönmesini bekliyor. // AContinuation: // a() fonksiyonunun durumu burada saklanır. // label = 2 → Üçüncü kez b() çağrılıyor. // user = User@1234 → readUser() çağrısı tamamlanmış, dönen değer burada tutuluyor. // completion = ... → Bu coroutine tamamlandığında daha üstteki (örneğin main) coroutine’e dönecek. // Bu zincir coroutine çağrı yığınının (stack) bir simülasyonudur. // Her suspend fonksiyon bir Continuation nesnesi oluşturur ve zincirin ucuna eklenir. // Askıya alındığında en son çağrılan continuation bellekte durur, // devam ettirildiğinde yukarı doğru completion zinciriyle sırayla devam eder.
Yukarıdaki temsile bakarak,"Tick"kaç kez yazdırılmıştır? (readUserfonksiyonunun askıya alınan bir fonksiyon
olmadığını varsayalım)5Doğru yanıt 13’tür.AContinuationnesnesindekilabeldeğeri 2 olduğundan, birbfonksiyonu çağrısı zaten.
Bu işlem tamamlandığında, o devam nesnesi, kendisini çağıran fonksiyonun devam nesnesini devam ettirir.
Bu süreç, çağrı yığınının en üstüne ulaşana kadar devam eder.
override fun resumeWith(result: Result<String>) { this.result = result // Suspend fonksiyondan dönen (veya hata fırlatılan) sonucu saklar. // Bu sonuç coroutine zincirine aktarılarak kaldığı yerden devam etmesi sağlanacaktır. val res = try { val r = printUser(token, this) // Coroutine fonksiyonu (örneğin printUser) kaldığı yerden çalıştırılır. // Bu fonksiyon genelde bir label değeriyle kontrol edilen state machine'dir. if (r == COROUTINE_SUSPENDED) return // Eğer coroutine delay gibi bir noktada yeniden askıya alındıysa, burada durulur. // Devam işlemi daha sonra tekrar yapılacaktır (örneğin başka bir callback’le tetiklenir). Result.success(r as Unit) // Askıya alınmadıysa coroutine başarıyla tamamlanmış demektir. // Bu durumda başarı sonucu bir Result nesnesine sarılır. } catch (e: Throwable) { Result.failure(e) // Eğer coroutine çalışırken istisna fırlatırsa burada yakalanır. // Ve hata bilgisi Result.failure olarak sarılır. } completion.resumeWith(res) // Üst continuation (yani bu coroutine’i çağıran fonksiyon) ile coroutine’in sonucu paylaşılır. // Böylece zincir yukarı doğru devam eder (örneğin main coroutine gibi). }
a fonksiyonunun b fonksiyonunu, b fonksiyonunun ise c fonksiyonunu çağırdığını ve c fonksiyonununaskıya alındığını düşünelim.
resume edildiğinde), aşağıdaki adımlar gerçekleşir:cdevam nesnesi (ccontinuation), öncecfonksiyonunu devam ettirir.cfonksiyonu tamamlandığında,cdevam nesnesibdevam nesnesini devam ettirir.bdevam nesnesibfonksiyonunu çağırır ve tamamlanmasını bekler.bfonksiyonu tamamlandığında,bdevam nesnesiadevam nesnesini devam ettirir.adevam nesnesiafonksiyonunu çağırarak süreci tamamlar.

Eğer bir istisna yakalanmazsa,
resumeWith içinde yakalanır ve Result.failure(e) ile sarılır.Daha sonra, bizim fonksiyonumuzu çağıran fonksiyon bu sonuç ile devam ettirilir.
- Fonksiyonun durumu bir devam nesnesinde (continuation) saklanmalıdır.
- Askıya alma mekanizması desteklenmelidir.
- Devam ettirme işlemi sırasında, devam nesnesinden (continuation) durum geri yüklenmeli ve döndürülen değer ya
kullanılmalı ya da bir istisna fırlatılmalıdır.

geçerlidir.
Tek fark, devam nesnesinin (continuation), fonksiyonun üyesi olduğu nesneye de referans tutması gerektiğidir.
Bu referans, fonksiyon devam ettirildiğinde doğru nesne üzerinde çağrılmasını sağlamak için gereklidir.
class UserRepository { suspend fun getUser(id: String): User { // Bu suspend fonksiyon askıya alınabilir. // Derleyici bu fonksiyonu otomatik olarak bir state machine’e çevirir. // Derin teknik olarak: çağrıldığında bir Continuation<User> nesnesi alır. return getUserFromApi(id) // Bu fonksiyon büyük olasılıkla yine suspend bir fonksiyondur. // Örneğin, uzak bir API çağrısı yapar ve coroutine’i askıya alır. // Askıya alma gerçekleşirse, UserRepository nesnesi ilgili Continuation içinde tutulur. // Bu sayede coroutine devam ettirildiğinde doğru `this` (yani UserRepository) referansı ile işlem devam eder. } // ... }
extension receiver) herhangi bir diğer parametre gibi işlenir.
Aslında perde arkasında sadece bir parametre olarak kabul edilir, bu yüzden devam nesnesinde (continuation)
saklanır.
Örneğin:
- Üye genişletme fonksiyonları (member extension functions)
- Inline sınıfların (inline class) içindeki fonksiyonlar
Her iki alıcı da devam nesnesinde otomatik olarak saklanır.
Bu karmaşıklığın sebebi çeşitli optimizasyonlar ve ek mekanizmalardır. Bunlardan bazıları:
- Daha iyi bir istisna (exception) yığın izleme (stack trace) oluşturma,
- Coroutine askıya alma müdahalesi ekleme (bu özelliği daha sonra ele alacağız),
- Kullanılmayan değişkenleri kaldırma veya kuyruk çağrısı optimizasyonu gibi performans artırıcı işlemler.
BaseContinuationImpl sınıfının bir bölümü yer almaktadır.Bu bölüm, gerçek
resumeWith metodunun nasıl uygulandığını göstermektedir (bazı yöntemler ve yorumlar kaldırılmıştır):import java.io.Serializable internal abstract class BaseContinuationImpl( val completion: Continuation<Any?>? ) : Continuation<Any?>, CoroutineStackFrame, Serializable { // Bu uygulama final olarak işaretlenmiştir. // Bu sayede resumeWith işlemi sırasında özyinelemeyi (recursion) açarak // daha okunaklı ve kısa bir yığın izi (stack trace) elde edilir. final override fun resumeWith(result: Result<Any?>) { // current.resumeWith(param) çağrısını döngüye alarak // özyinelemeyi açar ve daha anlaşılır bir stack trace sağlar. var current = this var param = result while (true) { // Her devam ettirilen (resumed) devam nesnesi için "resume" hata ayıklama probu (debug probe) çağrılır. // Böylece hata ayıklama altyapısı askıya alınan çağrı yığınının hangi kısmının devam ettirildiğini izleyebilir. probeCoroutineResumed(current) with(current) { val completion = completion!! // Eğer devam nesnesi tamamlanmamışsa hata fırlatır. val outcome: Result<Any?> = try { val outcome = invokeSuspend(param) if (outcome === COROUTINE_SUSPENDED) return Result.success(outcome) } catch (exception: Throwable) { Result.failure(exception) } releaseIntercepted() // Bu durum makinesi örneği sona eriyor. if (completion is BaseContinuationImpl) { // Özyinelemeyi döngü ile açar current = completion param = outcome } else { // En üst seviye tamamlanma noktası ulaşıldı, // sonucu çağırarak döndür. completion.resumeWith(outcome) return } } } } // ... }
kişi bu maliyetin yüksek olduğunu düşünebilir, ancak bu doğru değildir. Bir fonksiyonu durumlara (state) ayırmanın
maliyeti oldukça düşüktür; sayı karşılaştırmaları ve yürütme sıçramalarının maliyeti neredeyse yok denecek kadar azdır.
Bir devam nesnesinde (continuation) durum kaydetmek de ucuzdur. Yerel değişkenleri kopyalamıyoruz; yeni değişkenler
bellekteki aynı konumlara işaret eder. Gerçek maliyeti olan tek işlem bir devam sınıfı (continuation class)
oluşturmaktır, ancak bu da büyük bir sorun değildir. RxJava veya geri çağırmalar (callbacks) hakkında performans
kaygınız yoksa, askıya alınan fonksiyonların performansı hakkında da kaygılanmanıza gerek yoktur.
fikir verdiğini umuyorum. Temel noktalar şunlardır:
- Askıya alınan fonksiyonlar, fonksiyonun başında ve her askıya alınan fonksiyon çağrısından sonra belirli bir durumu
olabilen durum makineleri gibidir. - Bu durumu belirleyen sayı ve yerel değişkenlere ait referanslar, askıya alınan fonksiyonlar çağrılmadan önce devam
nesnesinde saklanır. - Bir fonksiyonun devam nesnesi, onu çağıran fonksiyonun devam nesnesini kapsar. Bu nedenle, bu devam nesnelerinin tümü,
fonksiyon devam ettirildiğinde veya tamamlandığında kullanılan bir çağrı yığını (call stack) oluşturur. - Bir askıya alınan fonksiyon devam ettirildiğinde, önce kendi fonksiyonunu çalıştırır. Bu işlem tamamlandığında, onu
çağıran fonksiyonun devam nesnesi devam ettirilir. Bu devam nesnesi de kendi fonksiyonunu çalıştırır ve bu işlem,
yığının en üstüne ulaşana kadar tekrarlanır.
- 1.Buradaki mekanizma aslında biraz daha karmaşıktır, çünkü
labelın ilk biti de değiştirilir ve bu değişiklik ↩ - 2.Daha somut bir ifadeyle,
COROUTINE_SUSPENDEDdeğeri, ya builder fonksiyonuna ya daresumefonksiyonuna ↩ - 3.Aynı durum (state) içinde tanımlanan ve kullanılan bir yerel değişken, devam nesnesinde saklanmak zorunda ↩
- 4.Çağrı yığınının (call stack) kullanılabilir alanı sınırlıdır. Bu alan tamamen kullanıldığında ↩
- 5.Doğru yanıt 13’tür.
AContinuationnesnesindekilabeldeğeri 2 olduğundan, birbfonksiyonu çağrısı zaten ↩