Kotlin Coroutines'de Askıya Alma (Suspension) Mekanizması

Kotlin Coroutines'de Askıya Alma (Suspension) Mekanizması

Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
Daha önce belirttiğimiz gibi coroutine'ler askıya alınabilen (suspend edilebilen) ve yeniden başlatılabilen
bileşenlerdir. Bu özellik kulağa thread'ler gibi gelebilir, ancak aralarında önemli farklar bulunmaktadır. Thread'ler
askıya alınamaz; yalnızca bloklanabilir. Bir thread bloklandığında1, hâlâ sistem kaynaklarını tüketmeye devam
eder ve işletim sistemi tarafından yönetilmesi gerekir. Coroutine ise askıya alındığında, geriye yalnızca coroutine’in
askıya alındığı noktayı ve yerel değişkenlere olan referansları tutan küçük bir nesne kalır. Coroutine'ler, thread'lerin
üzerinde çalışan hafif soyutlamalardır (lightweight abstractions) ve işletim sistemi değil, coroutine kütüphanesi
tarafından yönetilirler.

Oyun Metaforu Üzerinden Thread ve Coroutine Karşılaştırması

Thread ve coroutine arasındaki temel farkı açıklamak için oyunlar üzerinden etkili bir benzetme yapılabilir:
Bir thread, kayıt imkânı olmayan eski tip bir oyun gibidir. Oyuna ara vermek istediğinizde, oyunu kapatma şansınız
bulunmaz; yalnızca duraklatabilirsiniz. Bu durumda oyun arka planda çalışmaya ve bilgisayar kaynaklarını tüketmeye devam
eder. Coroutine ise, istediğiniz zaman kaydedebildiğiniz günümüz oyunlarına benzer. Bu modern oyunlarda dilediğiniz anda
oyunu kapatabilir, kaynakları boş yere tüketmemiş olursunuz. Ayrıca, bir oyunu kaydedip farklı oyunlara geçmeniz veya
kaydettiğiniz oyuna başka bir bilgisayardan devam etmeniz mümkündür. Örneğin internet kafelerde oynadığınız oyunları
farklı bilgisayarlardan sürdürebilmeniz gibi, coroutine'ler de benzer bir avantaj sunar.
Coroutine'lerin bu özelliği, askıya alma mekanizması (suspension mechanism) sayesinde gerçekleşir. Coroutine'ler
herhangi bir anda, herhangi bir thread üzerinde askıya alınabilir ve daha sonra farklı bir thread üzerinden kaldıkları
yerden devam ettirilebilir. Böylelikle coroutine'lerin askıya alınması, sistem kaynaklarını tüketmediği için neredeyse
hiç maliyet oluşturmaz. Bu özellik sayesinde tek bir thread üzerinde bile eş zamanlı olarak birden fazla coroutine
verimli biçimde çalıştırılabilir. Ayrıca coroutine'lerin sabit bir thread'e bağlı olmaması, thread kullanımını çok daha
etkin ve verimli hâle getirir.
Kitabın ilerleyen bölümlerinde bu avantajlar daha detaylı olarak incelenecektir. Şimdi, coroutine'lerin temel çalışma
prensibi olan askıya alma mekanizmasına daha yakından bakalım.

Askıya Alınabilen (Suspending) Fonksiyonlar

Bir uygulamayı, bloklayıcı (blocking) thread’lerden coroutine temelli askıya alma (suspension) modeline dönüştürürken
karşılaşılan en önemli değişiklik, birçok fonksiyonun başına eklenen suspend anahtar sözcüğüdür. Bu tür fonksiyonlara
askıya alınabilen (suspendable) fonksiyonlar denir ve bu fonksiyonlar Kotlin coroutine yapısının temel ayırt edici
özelliğini oluşturur. Coroutine kullanarak yazılmış basit bir backend uygulaması aşağıda verilmiştir. Coroutine
yaklaşımı ile geleneksel thread bloklama arasındaki temel farkın yalnızca fonksiyon tanımlarına eklenen suspendanahtar
sözcüğü olduğuna dikkat ediniz.
// GitHub API'siyle bağlantı kurmak için Retrofit arayüzü class GithubApi { // Belirtilen organizasyona ait 100 adet repoyu liste olarak getirir @GET("orgs/{organization}/repos?per_page=100") suspend fun getOrganizationRepos( // URL'deki {organization} parametresini temsil eder @Path("organization") organization: String ): List<Repo> // API'den dönen repo listesini temsil eder } // GitHub API'den veri alıp domain modeline dönüştüren servis sınıfı class GithubConnectorService( // GithubApi örneği dışarıdan dependency injection (DI) yoluyla alınır private val githubApi: GithubApi ) { // Kotlin organizasyonundaki repoları çekip domain objelerine dönüştürür suspend fun getKotlinRepos() = githubApi.getOrganizationRepos("kotlin") .map { it.toDomain() } // Repo nesnelerini domain modeline çevirir } // HTTP isteği alan ve response dönen controller sınıfı @Controller class UserController( // Github servis sınıfı dışarıdan DI ile alınır private val githubConnectorService: GithubConnectorService, ) { // /kotlin/repos endpoint'ine gelen GET isteğini karşılar @GetMapping("/kotlin/repos") suspend fun findUser(): GithubReposResponseJson = githubConnectorService.getKotlinRepos() .toJson() // Domain modelinden JSON response nesnesine dönüşüm }
Askıya Alınabilen (Suspending) Fonksiyonlar tam olarak nedir? Coroutine başlatırlar mı?
Hayır, başlatmazlar.
Askıya alınabilen fonksiyonlar yalnızca mevcut bir coroutine’i askıya alma yeteneğine sahip fonksiyonlardır. Bu
durum, askıya alınabilen fonksiyonların yalnızca aktif bir coroutine bağlamında çağrılabileceği anlamına gelir, çünkü
fonksiyonun askıya alabileceği (suspend edebileceği) bir coroutine olması gerekir. Pratikte askıya alınabilen
fonksiyonlar ya başka askıya alınabilen fonksiyonlar tarafından ya da coroutine oluşturucu yapılar (coroutine builders)
tarafından çağrılmalıdır. Tabii ki askıya alınabilen fonksiyonlar normal fonksiyonları da çağırabilir.
Askıya alınabilen fonksiyonlar, kendileri coroutine değildir; ancak coroutine'lere ihtiyaç duyarlar. Örneğin Spring Boot
gibi framework'ler, controller fonksiyonlarının başındaki suspend anahtar sözcüğünü tanır ve askıya alınabilen
fonksiyonları coroutine üzerinde çağırır. Diğer taraftan, Retrofit2 gibi ağ kütüphaneleri de aynı sebeple
suspend anahtar sözcüğüne tepki gösterir ve ağdan cevap beklerken thread'i bloklamak yerine coroutine'i askıya
alırlar.
Şimdi, bunu pratikte görelim. Bunun için bir coroutine'e ihtiyacımız var. Bir coroutine başlatmanın en basit yolu,
askıya alınabilen bir main fonksiyonu kullanmaktır. Bu tür fonksiyonlar Kotlin derleyicisi tarafından otomatik olarak
coroutine içine yerleştirilir ve başlatılır. Eğer bu main fonksiyonundan başka bir askıya alınabilen fonksiyon
çağırılırsa, bu fonksiyon aynı coroutine üzerinde çalıştırılır. Bir anlamda askıya alınabilen fonksiyonların senkronize
çalıştığını söyleyebiliriz; ancak bunu daha doğru ifade etmek gerekirse, askıya alınabilen fonksiyonlar coroutine
değildir, yalnızca var olan coroutine'i askıya alabilirler.
import kotlinx.coroutines.* // Askıya alınabilen fonksiyon bir coroutine'i askıya alabilir suspend fun a() { // Coroutine'i 1 saniye boyunca askıya alır delay(1000) println("A") } // Kotlin, askıya alınabilen main fonksiyonunu bir coroutine içinde başlatır suspend fun main() { println("Öncesi") a() println("Sonrası") } // Çıktı: // Öncesi // (1 saniyelik gecikme) // A // Sonrası
Dikkat ederseniz, eğer benzer kodu JavaScript’te askıya alınabilen fonksiyonlar yerine async fonksiyonlar kullanarak
yazsaydık, sonuç "Öncesi", "Sonrası", 1 saniyelik gecikme ve ardından "A" olurdu. Bunun sebebi,
JavaScript’teki async fonksiyonlarının coroutine olması ve her zaman asenkron işlemleri başlatmasıdır. *
Askıya alınabilen fonksiyonlar coroutine değildir; yalnızca coroutine'leri askıya alabilen fonksiyonlardır.* Bu iki
kavram karıştırılmamalıdır.

İlk Askıya Alma (Suspension) İşlemi

Ana (main) fonksiyonumuzun ortasında bir askıya alma işlemi gerçekleştirirsek ne olur?
Bunu test etmek için suspendCancellableCoroutine fonksiyonunu kullanabiliriz.
import kotlinx.coroutines.* //sampleStart suspend fun main() { println("Öncesi") suspendCancellableCoroutine<Unit> { } println("Sonrası") } // Öncesi //sampleEnd
suspendCancellableCoroutine, kotlinx.coroutines kütüphanesinden gelen bir fonksiyondur. Bunun yerine, Kotlin standart
kütüphanesinde yer alan suspendCoroutine fonksiyonunu kullanabiliriz. Her iki fonksiyon da bu bölümdeki tüm örneklerde
aynı davranışı sergileyecektir. Ancak, suspendCancellableCoroutine fonksiyonunu tercih etmek genellikle daha iyi bir
uygulamadır. Çünkü iptal işlemlerini destekler ve test edilebilirliği daha yüksektir. Yukarıdaki kodu çağırırsanız "
Sonrası"
çıktısını göremezsiniz ve kod çalışmayı durdurmaz. Bunun nedeni, main fonksiyonunun asla tamamlanmamasıdır.
Coroutine, "Öncesi" yazdırıldıktan sonra askıya alınır. Yani, oyunumuz durdurulmuş ve hiçbir zaman devam
ettirilmemiştir. Peki, coroutine’i nasıl devam ettirebiliriz?**suspendCancellableCoroutine** çağrısına tekrar göz
atalım. Bu çağrı, bir lambda ifadesi ({ }) ile sona ermektedir.Bu ifadeye geçirilen fonksiyon askıya alınmadan
önce çalıştırılır. Bu fonksiyonun argümanı, Continuation türündedir.Bu nesne, coroutine’in devam ettirilmesi
için kullanılabilir. Coroutine’i hemen devam ettirmek için aşağıdaki gibi kullanabiliriz3:
import kotlinx.coroutines.* import kotlin.coroutines.resume //örnekBaşlangıcı suspend fun main() { println("Öncesinde") suspendCancellableCoroutine<Unit> { continuation -> println("Askıya alınmadan hemen önce") continuation.resume(Unit) } println("Sonrasında") } // Öncesinde // Askıya alınmadan hemen önce // Sonrasında //örnekSonu
suspendCancellableCoroutine, kendisine verilen lambda ifadesini hemen çağırır. Bu davranış, Kotlin'deki let,
apply veya useLines gibi fonksiyonlarla benzerdir. Lambda ifadesinin hemen çağrılması, askıya alma (suspension)
işlemi gerçekleşmeden önce Continuation nesnesinin kullanılmasına olanak tanır. Eğer bu çağrı askıya alma işleminden
sonra gerçekleşseydi, Continuation nesnesinin yönetimi için çok geç olurdu.
Dolayısıyla, suspendCancellableCoroutine fonksiyonuna parametre olarak verilen lambda ifadesi, askıya alma
işleminden hemen önce çalıştırılır. Bu lambda, Continuation nesnesini saklamak veya daha sonra nasıl devam
ettirileceğini belirlemek için kullanılır.
Kotlin 1.3 sürümünden itibaren Continuation arayüzünün tanımı değiştirilmiştir. Daha önce resume ve
resumeWithException fonksiyonları vardı. Ancak şimdi Result türü bekleyen tek bir resumeWith fonksiyonu
bulunmaktadır. Bizim kullandığımız resume ve resumeWithException fonksiyonları ise, aslında resumeWith üzerinde
çalışan standart kütüphane genişletme (extension) fonksiyonlarıdır.
inline fun <T> Continuation<T>.resume(value: T): Unit = resumeWith(Result.success(value)) inline fun <T> Continuation<T>.resumeWithException( exception: Throwable ): Unit = resumeWith(Result.failure(exception))

Devam Nesnesinde (Continuation) Neler Saklanır?

Devam nesnesi (Continuation), coroutine'in durumunu saklayan bir nesnedir. Bu nesne, yerel değişkenleri ve
coroutine’in askıya alındığı noktayı içerir. Bir coroutine askıya alındığında, çalıştığı yer ve tüm bağlamsal veriler
bu nesne içinde saklanır.
Bu yapının nasıl çalıştığını bir sonraki bölümde daha ayrıntılı olarak ele alacağız. Ancak şimdilik, devam nesnesinin
içinde ne olduğunu anlamak için aşağıdaki kodu inceleyelim:
import kotlinx.coroutines.delay import kotlinx.coroutines.suspendCancellableCoroutine import kotlin.coroutines.resume // Coroutine desteği olan bir suspend fonksiyon tanımlıyoruz suspend fun a() { // Bu değişken coroutine içerisinde tanımlanmış bir string val a = "ABC" // Coroutine’i manuel olarak durdurup devam ettirebildiğimiz bir yapı // Bu fonksiyon coroutine’i askıya alır ve aşağıdaki blok çalıştırılır suspendCancellableCoroutine<Unit> { continuation -> // continuation, coroutine’in kaldığı noktayı temsil eder. // Bu satır, coroutine’in çalışmaya devam etmesini sağlar continuation.resume(Unit) } // coroutine kaldığı yerden devam eder ve bu satır yazdırılır println(a) } // Main coroutine fonksiyonu (suspend olduğu için coroutine context'inde çalışır) suspend fun main() { // Basit bir liste oluşturuluyor val list = listOf(1, 2, 3) // Bir metin değişkeni val text = "Bir metin" // Önce metin yazdırılır println(text) // 1 saniye beklenir (asenkron olarak) delay(1000) // Yukarıda tanımlanan `a()` fonksiyonu çalıştırılır // Bu fonksiyon suspend olduğu için coroutine tarafından duraklatılabilir a() // Liste yazdırılır println(list) }
Devam nesnesinde (Continuation) neyin saklanmasını beklersiniz? Bu nesne, Kotlin tarafından askıya alınan main
fonksiyonunun durumunu içermelidir. Bu nedenle, yalnızca a fonksiyonunun yerel değişkenlerini değil, aynı zamanda
askıya alındıktan sonra kullanılan main fonksiyonunun yerel değişkenlerini de içermelidir.
askıya alındıktan sonra kullanılan main fonksiyonunun yerel değişkenlerini de içermelidir.
Coroutine’in askıya alındığı noktadan devam edebilmesini sağlamak için aşağıdaki bilgiler devam nesnesinde
saklanmalıdır:
  • list ve a değişkenlerinin referansları.
  • Coroutine’in askıya alındığı konum bilgisi:
    • a fonksiyonu için label 1.
    • main fonksiyonu için label 2 (çünkü delay işlemi label 1'i alır).
Bu temel noktalar, devam nesnesinin ne olduğunu ve nasıl çalıştığını açıklamak için gereklidir. Ayrıntılar bir sonraki
bölümde ele alınacaktır.

Coroutine’i Geciktirme

Bir coroutine’i belirli bir süre boyunca nasıl askıya alabiliriz? En basit yöntem, devam nesnesini belirli bir süre
sonra devam ettirecek bir iş parçacığı (thread) başlatmak olabilir. Bu yöntem şu şekilde uygulanabilir:
import kotlin.concurrent.thread import kotlinx.coroutines.* import kotlin.coroutines.resume //sampleStart // Bu bir suspend main fonksiyonudur, coroutine context'inde çalışır suspend fun main() { // Coroutine başlamadan önce konsola yazdırılır println("Öncesi") // Coroutine’i askıya almak için kullanılır — iptal edilebilir suspendCancellableCoroutine<Unit> { continuation -> // Yeni bir Java thread’i başlatılır thread { // Coroutine burada askıya alınmıştır (suspend edilmiş) println("Askıya alındı") // Thread 1 saniye bekletilir (bloklayıcı şekilde) Thread.sleep(1000) // Coroutine kaldığı yerden devam ettirilir continuation.resume(Unit) // Bu satır, coroutine'in dışı bir thread içinde yazılır println("Devam ettirildi") } } // Coroutine devam eder ve bu satır yazdırılır println("Sonrası") } // Öncesi // Askıya alındı // (1 saniyelik gecikme) // Sonrası // Devam ettirildi //sampleEnd
Elbette, bu yaklaşım pratik değildir çünkü iş parçacıkları (threads) pahalıdır ve yalnızca bir coroutine’i kısa
süreliğine askıya almak için yeni bir iş parçacığı oluşturulmamalıdır. Ancak, devam nesnesinin başka bir iş parçacığına
aktarılabileceğini ve farklı bir iş parçacığından devam ettirilebileceğini vurgulamak önemlidir.
Ayrıca, belirli bir süre sonra devam nesnesini çalıştıran bir fonksiyon tanımlamak da mümkündür. Böyle bir durumda,
devam nesnesi lambda ifadesi tarafından yakalanır ve aşağıdaki kod kesitinde gösterildiği gibi kullanılabilir.
import kotlin.concurrent.thread import kotlinx.coroutines.* import kotlin.coroutines.* //örnek başlangıcı fun continueAfterSecond(continuation: Continuation<Unit>) { // Yeni bir iş parçacığında (thread) çalıştır thread { // 1 saniye beklet Thread.sleep(1000) // 1 saniye sonunda coroutine'in kaldığı yerden devam etmesini sağla continuation.resume(Unit) } } // `main` fonksiyonu suspend (askıya alınabilir) bir fonksiyondur suspend fun main() { // Coroutine başlatılmadan önce bu satır yazdırılır println("Öncesi") // `suspendCancellableCoroutine` coroutine’i manuel olarak devam ettirmek için kullanılır suspendCancellableCoroutine<Unit> { continuation -> // 1 saniye sonra devam ettirilecek işlemi başlat continueAfterSecond(continuation) } // Coroutine 1 saniye bekledikten sonra buradan devam eder println("Sonrası") } // Program çıktısı: // Öncesi // (1 saniye bekleme) //örnek sonu
Bu mekanizma çalışsa da, yalnızca bir saniyelik bekleme süresi için gereksiz iş parçacıkları (threads) oluşturup
sonlandırmak kaynak israfına yol açar. İş parçacıkları pahalıdır ve bu nedenle mümkün olduğunca verimli kullanılmalıdır.
Bunun yerine, bir "alarm saati(alarm clock)" mekanizması kurmak daha iyi bir çözüm olacaktır. JVM üzerinde bu
amaçla *
ScheduledExecutorService* kullanılabilir. Bu yöntem, belirlenen bir süre sonunda continuation.resume(Unit)
çağrılarak devam nesnesinin yürütülmesini sağlar. Böylece, iş parçacıkları gereksiz yere kullanılmaz ve sistem
kaynakları daha etkin bir şekilde yönetilir.
import java.util.concurrent.* import kotlinx.coroutines.* import kotlin.coroutines.resume // örnek başlangıcı // Tek iş parçacıklı zamanlayıcı (scheduler) oluşturuluyor. // Bu executor, zamanlanmış görevleri belirli bir gecikmeyle çalıştırmak için kullanılır. // "scheduler" adında daemon (arka plan) bir thread kullanır. private val executor = Executors.newSingleThreadScheduledExecutor { Thread(it, "scheduler").apply { isDaemon = true } } suspend fun main() { // Coroutine başlamadan önce bu satır yazdırılır println("Öncesi") // Cancellable (iptal edilebilir) bir coroutine bloğu başlatılır suspendCancellableCoroutine<Unit> { continuation -> // Executor, 1000 milisaniye (1 saniye) sonra continuation.resume(Unit) çağırarak coroutine'e devam ettirir executor.schedule({ continuation.resume(Unit) }, 1000, TimeUnit.MILLISECONDS) } // 1 saniyelik gecikmeden sonra coroutine buradan devam eder println("Sonrası") } // Program çıktısı: // Öncesi // (1 saniye gecikme) // örnek sonu
Belirli bir süre boyunca coroutine'i askıya almak, oldukça faydalı bir işlemdir. Bu yüzden, bu işlemi soyutlayarak bir *
delay* fonksiyonu oluşturabiliriz.
import java.util.concurrent.* import kotlinx.coroutines.* import kotlin.coroutines.resume // örnek başlangıcı // Tek iş parçacıklı zamanlayıcı (scheduler) oluşturuluyor // Bu zamanlayıcı, gecikmeli görevler çalıştırmak için kullanılacak private val executor = Executors.newSingleThreadScheduledExecutor { // Thread'e "scheduler" adını veriyoruz ve arka plan (daemon) olarak işaretliyoruz Thread(it, "scheduler").apply { isDaemon = true } } // Coroutine içinde kullanılmak üzere, özel bir gecikme (delay) fonksiyonu yazıyoruz // Standart delay() gibi çalışıyor ama kendi zamanlayıcımızı kullanıyor suspend fun delay(timeMillis: Long): Unit = suspendCancellableCoroutine { cont -> // Belirtilen süre (timeMillis) kadar bekledikten sonra coroutine'e devam edilir executor.schedule({ cont.resume(Unit) // Coroutine kaldığı yerden devam eder }, timeMillis, TimeUnit.MILLISECONDS) } suspend fun main() { // Coroutine çalışmaya başlar println("Öncesi") // Bu satır hemen yazdırılır // delay fonksiyonu çağrılır, coroutine burada askıya alınır (suspend edilir) delay(1000) // 1000 milisaniye (1 saniye) bekle // Bekleme tamamlandıktan sonra coroutine devam eder println("Sonrası") // Bu satır 1 saniye sonra yazdırılır } // Çıktı: // Öncesi // (1 saniye bekleme) // örnek sonu
executor hâlâ bir iş parçacığı thread kullanmaktadır, ancak bu iş parçacığı tüm coroutine’ler tarafından
paylaşıldığı için oldukça verimli bir yöntemdir. Bu, her bir bekleme süresi için ayrı bir iş parçacığı oluşturmak yerine
tek bir iş parçacığının kullanılması anlamına gelir.
Bu yaklaşım, Kotlin Coroutines kütüphanesindeki eski delay fonksiyonunun uygulanma şekline çok benzerdir. Ancak,
kütüphanenin güncel sürümlerinde delay fonksiyonunun implementasyonu daha karmaşıktır. Bunun başlıca sebebi:
  • Test Edilebilirlik : delay fonksiyonu test ortamlarında kontrol edilebilir bir zaman ilerletme mekanizması
    sağlamaktadır.
  • Daha İyi Planlama Mekanizması : Asenkron işlem sürekliliği ve performans optimizasyonları için eklemeler
    yapılmıştır.
Temel fikir değişmese de, Kotlin Coroutines kütüphanesi daha gelişmiş ve güvenilir bir mekanizma sunmak adınadelay
fonksiyonunu daha kapsamlı hâle getirmiştir.

Bir Değer ile Devam Etme

resume fonksiyonuna neden Unit değeri geçirdiğimiz ve suspendCancellableCoroutineiçin
neden Unit türünü kullandığımız dikkatinizi çekmiş olabilir. Bu bir tesadüf değildir.
val ret: Unit = suspendCancellableCoroutine<Unit> { c -> c.resume(Unit) }
resume çağrısı yapıldığında, döndürülen değerin suspendCancellableCoroutine fonksiyonunun türü ile aynı olması gerekir.
suspendCancellableCoroutine çağrılırken hangi tür belirlendiyse, resume çağrısında da aynı tür kullanılmalıdır.
import kotlinx.coroutines.* import kotlin.coroutines.resume // örnek başlangıcı suspend fun main() { val i: Int = suspendCancellableCoroutine<Int> { c -> c.resume(42) } // suspendCancellableCoroutine coroutine’i askıya alır. // resume(42) çağrıldığında coroutine devam eder ve 42 değeri döner. // Bu değer değişken `i`'ye atanır. println(i) // 42 // i değişkeni ekrana yazdırılır. val str: String = suspendCancellableCoroutine<String> { c -> c.resume("Some text") } // Aynı yapı burada bir String değeri için uygulanır. // coroutine devam ederken "Some text" değeri döner ve str değişkenine atanır. println(str) // Some text // str değişkeni ekrana yazdırılır. val b: Boolean = suspendCancellableCoroutine<Boolean> { c -> c.resume(true) } // Bu kez Boolean tipiyle çalışılır. // coroutine true değeriyle devam eder ve bu değer b değişkenine atanır. println(b) // true // b değişkeni ekrana yazdırılır. } // Çıktı: // 42 // Some text // true // örnek sonu
Bu durum oyun analojisiyle tam olarak örtüşmez. Kaydedilmiş bir oyunu tekrar yüklediğinizde içine yeni bir şey
ekleyebileceğiniz bir oyun bilmiyorum4 (tabii ki hile yapıp bir sonraki bölümü nasıl geçeceğinizi Google'da
aramadıysanız). Ancak, Coroutine'lerle bu durum tamamen mantıklıdır. Genellikle bir veri beklediğimiz için askıya alınırız;
örneğin, bir API'den gelen ağ yanıtını bekleriz. Bu oldukça yaygın bir senaryodur.
Bir iş parçacığı (thread), belirli bir noktaya kadar iş mantığını yürütür ve ardından bir veriye ihtiyaç duyar. Bu
noktada, ağ kütüphanesinden veriyi getirmesini ister. Coroutine'ler olmadan, bu iş parçacığının veriyi beklemesi gerekir.
Ancak iş parçacıkları pahalıdır, özellikle de Android'deki Ana İş Parçacığı (Main Thread) gibi kritik bir iş
parçacığıysa, böyle bir bekleme büyük bir kaynak israfı olur. Coroutine'ler sayesinde iş parçacığı yalnızca askıya alınır
ve kütüphaneye şu talimatı verir: "Bu veriyi aldığında, resume fonksiyonuna ilet". Böylece iş parçacığı bu bekleme
süresince başka işlerle ilgilenebilir. Veri geldiğinde ise, Coroutine'in askıya alındığı yerden devam etmesi için iş
parçacığı yeniden kullanılır.
Bu durumu pratiğe dökmek için, bir veri alana kadar nasıl askıya alınabileceğimizi inceleyelim. Aşağıdaki örnekte,
dışarıda tanımlanmış requestUser adlı bir geri çağırma (callback) fonksiyonunu kullanıyoruz.
import kotlin.concurrent.thread import kotlinx.coroutines.* import kotlin.coroutines.resume data class User(val name: String) // Basit bir veri sınıfı: sadece bir `name` (isim) alanı içerir. fun requestUser(callback: (User) -> Unit) { thread { Thread.sleep(1000) callback.invoke(User("Test")) } } // Bu fonksiyon 1 saniye gecikmeyle bir `User` nesnesi oluşturur ve geri çağırma (callback) fonksiyonuna iletir. // Yeni bir iş parçacığında çalışır, böylece ana akışı (main thread) bloke etmez. // örnek başlangıcı suspend fun main() { println("Önce") // Coroutine başlarken bu satır hemen yazdırılır. val user = suspendCancellableCoroutine<User> { cont -> requestUser { user -> cont.resume(user) } } // suspendCancellableCoroutine coroutine'i askıya alır. // requestUser çalıştırılır; 1 saniye sonra bir `User` döner. // Kullanıcı nesnesi geldikten sonra resume ile coroutine kaldığı yerden devam eder. println("Kullanıcı: $user") // Kullanıcı bilgisi ekrana yazdırılır: User(name=Test) println("Sonra") // Son satır ekrana yazdırılır. } // Çıktı: // Önce // (1 saniye gecikme) // Kullanıcı: User(name=Test) // Sonra // örnek sonu
suspendCancellableCoroutine fonksiyonunu doğrudan çağırmak kullanışlı değildir. Bunun yerine, askıya alınabilir (
suspending) bir fonksiyonun oluşturulması daha uygun olacaktır. Bu amaçla söz konusu yapıyı ayrı bir askıya alınabilir
fonksiyona dönüştürebiliriz.
import kotlin.concurrent.thread import kotlinx.coroutines.* import kotlin.coroutines.resume data class User(val name: String) // `User` adında, sadece bir `name` (isim) alanına sahip basit bir veri sınıfı tanımlanıyor. fun requestUser(callback: (User) -> Unit) { thread { Thread.sleep(1000) callback.invoke(User("Test")) } } // Bu fonksiyon 1 saniye gecikmeyle çalışan bir iş parçacığı başlatır. // Süre dolunca callback fonksiyonunu `User("Test")` nesnesiyle çağırır. // Bu klasik bir asenkron callback yapısıdır. suspend fun requestUser(): User { return suspendCancellableCoroutine<User> { cont -> requestUser { user -> cont.resume(user) } } } // Bu fonksiyon, yukarıdaki callback tabanlı `requestUser` fonksiyonunu bir `suspend` fonksiyona dönüştürür. // `suspendCancellableCoroutine` coroutine'i askıya alır. // Geriye bir `User` döneceği garanti edildiği için türü `User` olarak tanımlanır. // Callback'ten gelen kullanıcı nesnesi `resume(user)` ile coroutine'e iletilir. suspend fun main() { println("Önce") // Coroutine başlar başlamaz bu satır yazdırılır. val user = requestUser() // `requestUser` çağrılır ve coroutine burada askıya alınır. // 1 saniye sonra veri geldiğinde coroutine devam eder ve sonuç `user` değişkenine atanır. println("Kullanıcı: $user") // Kullanıcı bilgisi yazdırılır: User(name=Test) println("Sonra") // Son satır yazdırılır. }
Askıya alınabilir fonksiyonlar (suspending functions), günümüzde Retrofit ve Room gibi popüler kütüphaneler tarafından
hâlihazırda desteklenmektedir. Bu sebeple, askıya alınabilir fonksiyonlar içinde geri çağırım (callback) fonksiyonlarını
kullanmaya nadiren ihtiyaç duyarız. Bununla birlikte, gerektiğinde geri çağırım fonksiyonlarını askıya alınabilir
fonksiyonlara nasıl dönüştüreceğimizi bilmemiz faydalıdır.
API’nin bize veri yerine bir tür sorun iletmesi durumunda ne olacağı merak konusu olabilir. Örneğin, servis çalışmaz
durumdaysa ya da bir hata mesajıyla yanıt verirse ne olur? Böyle bir durumda veri döndürmek mümkün değildir; bunun
yerine coroutine’in askıya alındığı noktadan bir istisna (exception) fırlatmalıyız. İşte tam bu noktada, coroutine’i bir
istisna ile devam ettirme (resume with exception) işlemine ihtiyaç duyarız.

İstisna (Exception) ile Devam Ettirme (Resume)

Çağırdığımız her fonksiyon, ya bir değer döndürebilir ya da bir istisna (exception) fırlatabilir. Aynı durum
suspendCancellableCoroutine için de geçerlidir. resume fonksiyonu çağrıldığında, argüman olarak aldığı veriyi döndürür.
resumeWithException fonksiyonu çağrıldığında ise argüman olarak alınan istisna, coroutine’in askıya alındığı noktadan
kavramsal olarak fırlatılmış olur.
import kotlinx.coroutines.* import kotlin.coroutines.resumeWithException //örnekBașlangıcı class MyException : Throwable("Yalnızca bir istisna") // Özel bir istisna sınıfı tanımlanıyor. Mesajı: "Yalnızca bir istisna" suspend fun main() { try { suspendCancellableCoroutine<Unit> { cont -> cont.resumeWithException(MyException()) } // suspendCancellableCoroutine coroutine’i askıya alır. // cont.resumeWithException ile coroutine, hata fırlatarak devam ettirilir. } catch (e: MyException) { println("İstisna yakalandı!") // Fırlatılan istisna burada yakalanır ve ekrana yazdırılır. } } // İstisna yakalandı! //örnekSonu
Bu mekanizma, örneğin ağ (network) bağlantılarında ortaya çıkan hataları belirtmek ve yönetmek amacıyla kullanılır.
Böylece ağ bağlantısı sırasında oluşan istisnai durumlar, coroutine’lerin askıya alındığı noktada belirtilerek,
uygulamanın hata durumlarını uygun şekilde işlemesi sağlanır.
suspend fun requestUser(): User { return suspendCancellableCoroutine<User> { cont -> requestUser { resp -> if (resp.isSuccessful) { cont.resume(resp.data) } // Eğer yanıt başarılıysa, coroutine'e veri gönderilerek devam ettirilir. else { val e = ApiException( resp.code, resp.message ) cont.resumeWithException(e) // Hata durumu varsa özel bir ApiException fırlatılarak coroutine bir istisna ile devam ettirilir. } } } } suspend fun requestNews(): News { return suspendCancellableCoroutine<News> { cont -> requestNews( onSuccess = { news -> cont.resume(news) }, // Başarılı yanıt geldiğinde coroutine devam eder ve haber nesnesi döner. onError = { e -> cont.resumeWithException(e) } // Hata oluştuğunda coroutine, exception ile devam ettirilir. ) } }

Askıya alınan Coroutine'dir , fonksiyon değil

Burada vurgulanması gereken önemli bir nokta, askıya alınanın fonksiyon değil, coroutine olduğudur. Askıya alınabilir
fonksiyonların kendileri coroutine değildir; yalnızca bir coroutine’i askıya alabilen fonksiyonlardır5. Bir
fonksiyonu bir değişkene atayıp daha sonra fonksiyon çağrısından sonra devam ettirmeye çalıştığımızı varsayalım. Bu
mümkün değildir, çünkü askıya alınan şey fonksiyonun kendisi değil, çağrıldığı coroutine’dir.
import kotlinx.coroutines.* import kotlin.coroutines.resume // örnek başlangıcı var continuation: Continuation<Unit>? = null // Global bir değişken olarak Continuation saklanıyor. // Bu sayede coroutine'in kontrolünü dışarıdan alabiliyoruz. suspend fun suspendAndSetContinuation() { suspendCancellableCoroutine<Unit> { cont -> continuation = cont } } // Bu fonksiyon çağrıldığında coroutine askıya alınır. // Devam ettirme nesnesi (Continuation) global değişkene atanır ve coroutine durur. suspend fun main() { println("Önce") // Programın başında bu satır hemen yazdırılır. suspendAndSetContinuation() // Bu satırda coroutine askıya alınır. Devam etme noktası yukarıdaki değişkende saklanır. continuation?.resume(Unit) // Coroutine dışarıdan, manuel olarak kaldığı yerden devam ettirilir. println("Sonra") // Coroutine devam ettiğinde bu satır çalışır ve yazdırılır. } //Önce // örnek sonu
Bu mantıklı değildir. Bir oyunu durdurup, oyunun daha sonraki bir aşamasından kaldığı yerden devam ettirmeye çalışmak
gibidir. Böyle bir durumda resume fonksiyonu asla çağrılmaz. Ekranda yalnızca “Önce” ifadesini görürsünüz ve
programınız, başka bir iş parçacığı (thread) veya başka bir coroutine tarafından devam ettirilmediği sürece asla
sonlanmaz. Bu durumu daha iyi göstermek için coroutine’i bir saniye sonra devam ettirecek başka bir coroutine
oluşturabiliriz.
import kotlinx.coroutines.* import kotlin.coroutines.* // örnek başlangıcı // Bunu yapmayın, potansiyel bellek sızıntısı var continuation: Continuation<Unit>? = null // Global bir continuation nesnesi tanımlanıyor. // Bu, coroutine’in kontrolünü dışarıdan almak için kullanılıyor. // Ancak bu yapı bellek sızıntılarına neden olabilir, önerilmez. suspend fun suspendAndSetContinuation() { suspendCancellableCoroutine<Unit> { cont -> continuation = cont } } // Bu fonksiyon çağrıldığında coroutine askıya alınır // ve continuation nesnesi dışarı aktarılır. suspend fun main(): Unit = coroutineScope { println("Önce") // Uygulama başlarken bu satır hemen yazdırılır. launch { delay(1000) continuation?.resume(Unit) } // Yeni bir coroutine başlatılıyor ve 1 saniye gecikmeden sonra // dışarıda saklanan continuation ile ana coroutine devam ettiriliyor. suspendAndSetContinuation() // Bu satırda coroutine durur, bekler. println("Sonra") // 1 saniye sonra continuation ile coroutine devam ettirilince bu satır yazdırılır. } // Önce // (1 saniye gecikme) // Sonra // örnek sonu

Özet

Umarım şimdi askıya alma (suspension) mekanizmasının, kullanıcının bakış açısına göre nasıl çalıştığını net bir şekilde
kavrayabilmişsinizdir. Bu konu, kitap boyunca inşa edeceğimiz önemli bir temeldir. Ayrıca, geri çağırım (callback)
fonksiyonlarını askıya alınabilir fonksiyonlara dönüştürme gibi bazı pratik desenleri öğrenmiş oldunuz. Eğer benim
gibiyseniz ve her şeyin tam olarak nasıl işlediğini anlamak istiyorsanız, askıya alma mekanizmasının nasıl implement
edildiği hakkında hala merak içinde olabilirsiniz. Bu konuda daha fazla bilgi edinmek isterseniz, konu bir sonraki
bölümde ele alınacaktır. Ancak bunun pratikte ne kadar gerekli olduğunu düşünmüyorsanız, sonraki kısmı atlayabilirsiniz.
Çünkü bu detaylar, Kotlin coroutine’lerinin içsel işleyişine dair daha çok teknik bir derinlik sunar, ancak doğrudan
uygulama geliştirme pratiği ile pek ilişkili değildir.
  1. 1.Thread bloklama (Thread blocking): Bir thread’in, belirli bir koşulun gerçekleşmesini beklemek amacıyla geçici ↩
  2. 2.Eğer ağ istemcisi kütüphanesi seçme aşamasındaysanız, Retrofit yerine Ktor Client kullanmanızı öneririm. Ktor, ↩
  3. 3.Bu ifade genel olarak doğru olsa da açıklığa kavuşturulması gereken bir noktadır. Burada askıya alma ve hemen ↩
  4. 4.Bir atölye çalışmasında, böyle bir oyunun var olduğu öğrenildi: Don’t Starve Together oyununda, oyunu devam ↩
  5. 5.main fonksiyonunun askıya alınması özel bir durumdur. Kotlin derleyicisi, bu fonksiyonu otomatik olarak bir ↩