
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
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ığında1Thread bloklama (Thread blocking): Bir thread’in, belirli bir koşulun gerçekleşmesini beklemek amacıyla geçici, 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.
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.
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.
prensibi olan askıya alma mekanizmasına daha yakından bakalım.
karşılaşılan en önemli değişiklik, birçok fonksiyonun başına eklenen
suspend anahtar sözcüğüdür. Bu tür fonksiyonlaraaskı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
suspendanahtarsö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 }
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.
gibi framework'ler,
controller fonksiyonlarının başındaki suspend anahtar sözcüğünü tanır ve askıya alınabilenfonksiyonları coroutine üzerinde çağırır. Diğer taraftan, Retrofit2Eğer ağ istemcisi kütüphanesi seçme aşamasındaysanız, Retrofit yerine Ktor Client kullanmanızı öneririm. Ktor, 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ıyaalırlar.
askıya alınabilen bir
main fonksiyonu kullanmaktır. Bu tür fonksiyonlar Kotlin derleyicisi tarafından otomatik olarakcoroutine 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 yerineasyncfonksiyonlar kullanarak
yazsaydık, sonuç "Öncesi", "Sonrası", 1 saniyelik gecikme ve ardından "A" olurdu. Bunun sebebi,
JavaScript’tekiasyncfonksiyonları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.
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 standartkütüphanesinde yer alan
suspendCoroutine fonksiyonunu kullanabiliriz. Her iki fonksiyon da bu bölümdeki tüm örneklerdeaynı davranışı sergileyecektir. Ancak,
suspendCancellableCoroutine fonksiyonunu tercih etmek genellikle daha iyi biruygulamadı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özatalı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 ettirilmesiiçin kullanılabilir. Coroutine’i hemen devam ettirmek için aşağıdaki gibi kullanabiliriz3Bu ifade genel olarak doğru olsa da açıklığa kavuşturulması gereken bir noktadır. Burada askıya alma ve hemen:
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şlemindensonra gerçekleşseydi,
Continuation nesnesinin yönetimi için çok geç olurdu.suspendCancellableCoroutine fonksiyonuna parametre olarak verilen lambda ifadesi, askıya almaişleminden hemen önce çalıştırılır. Bu lambda,
Continuation nesnesini saklamak veya daha sonra nasıl devamettirileceğini belirlemek için kullanılır.
Kotlin 1.3 sürümünden itibarenContinuationarayüzünün tanımı değiştirilmiştir. Daha önceresumeve
resumeWithExceptionfonksiyonları vardı. Ancak şimdiResulttürü bekleyen tek birresumeWithfonksiyonu
bulunmaktadır. Bizim kullandığımızresumeveresumeWithExceptionfonksiyonları ise, aslındaresumeWithü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))
Continuation), coroutine'in durumunu saklayan bir nesnedir. Bu nesne, yerel değişkenleri vecoroutine’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.
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) }
Continuation) neyin saklanmasını beklersiniz? Bu nesne, Kotlin tarafından askıya alınan mainfonksiyonunun durumunu içermelidir. Bu nedenle, yalnızca
a fonksiyonunun yerel değişkenlerini değil, aynı zamandaaskı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.saklanmalıdır:
listveadeğişkenlerinin referansları.- Coroutine’in askıya alındığı konum bilgisi:
afonksiyonu için label 1.mainfonksiyonu için label 2 (çünküdelayişlemi label 1'i alır).
bölümde ele alınacaktır.

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
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.
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
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.
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
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ındanpaylaşı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.
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 :
delayfonksiyonu 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.
delayfonksiyonunu daha kapsamlı hâle getirmiştir.
resume fonksiyonuna neden Unit değeri geçirdiğimiz ve suspendCancellableCoroutineiçinneden
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) }
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
ekleyebileceğiniz bir oyun bilmiyorum4Bir atölye çalışmasında, böyle bir oyunun var olduğu öğrenildi: Don’t Starve Together oyununda, oyunu devam (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.
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 beklemesü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.
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. }
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.
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.
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
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. ) } }
fonksiyonların kendileri coroutine değildir; yalnızca bir coroutine’i askıya alabilen fonksiyonlardır5main fonksiyonunun askıya alınması özel bir durumdur. Kotlin derleyicisi, bu fonksiyonu otomatik olarak bir. 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
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
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.Thread bloklama (Thread blocking): Bir thread’in, belirli bir koşulun gerçekleşmesini beklemek amacıyla geçici ↩
- 2.Eğer ağ istemcisi kütüphanesi seçme aşamasındaysanız, Retrofit yerine Ktor Client kullanmanızı öneririm. Ktor, ↩
- 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.Bir atölye çalışmasında, böyle bir oyunun var olduğu öğrenildi: Don’t Starve Together oyununda, oyunu devam ↩
- 5.main fonksiyonunun askıya alınması özel bir durumdur. Kotlin derleyicisi, bu fonksiyonu otomatik olarak bir ↩