Neden Kotlin Coroutines Kullanmalıyız?

Neden Kotlin Coroutines Kullanmalıyız?

Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
Birçok geliştirici coroutineleri hafif iş parçacıkları (lightweight thread) olarak değerlendirir, ancak coroutineler
bundan çok daha fazlasıdır. 1963 yılında ilk kez tanımlanan bir kavramın1 endüstriyel ölçekte uygulanabilir bir
versiyonunun geliştirilmesi uzun yıllar almıştır2.
Kotlin Coroutines kütüphanesi, yarım yüzyıllık akademik çalışmalarda sunulan güçlü özellikleri, gerçek dünya
senaryolarına güvenli ve basit bir şekilde entegre edilebilecek bir biçimde sunmaktadır. Dahası, Kotlin Coroutines çoklu
platform (multiplatform) desteğine sahiptir. Bu, JVM, JS, iOS gibi tüm Kotlin platformlarında ve ortak (common)
modüllerde kullanılabileceği anlamına gelmektedir.
Bununla birlikte, coroutineler oldukça verimlidir: RxJava veya Reactor gibi kütüphanelerden belirgin şekilde daha
verimli olup, klasik engelleme tabanlı (blocking) iş parçacıklarına kıyasla karşılaştırılamayacak kadar yüksek
performanslıdır. Ayrıca, kod yapısını kökten değiştirmezler. Kotlin Coroutines’in sunduğu yeteneklerin büyük bir kısmını
neredeyse zahmetsiz bir şekilde kullanabiliriz (ki aynı şeyi RxJava veya geri çağrı (callback) mekanizmaları için
söylemek mümkün değildir). Bu özellikleri sayesinde Kotlin Coroutines, yeni başlayanlar için de oldukça erişilebilir bir
teknoloji sunmaktadır3.
Bu bölümde, Kotlin Coroutines’in temel avantajlarını genel bir bakış açısıyla ele alacak ve daha sonraki bölümlerde bu
avantajları detaylı bir şekilde inceleyeceğiz.

Basitlik (Simplicity)

Kotlin Coroutines, yaygın kullanım senaryolarını basitleştirmek için tasarlanmıştır. Bize, işlem sırasında ana iş
parçacığını (main thread) bloklamadan emredici (imperative) bir stil kullanma veya daha az kod tekrarı (boilerplate) ile
reaktif bir yaklaşım benimseme imkanı sunar.
Bu özellik özellikle Android ve JavaScript gibi ön yüz (frontend) platformlarında büyük avantaj sağlar.
Uygulamalarımızın büyük bir kısmı ana iş parçacığında (main thread) çalışır ve burada engelleyici işlemler (blocking
operations) mümkün değildir. Ancak coroutine'lerin askıya alınması (suspending) herhangi bir sorun oluşturmaz.
Kotlin Coroutines, kodun en doğal ve sezgisel şekilde yazılmasına, kolay hata ayıklamaya (debugging) ve bakımı daha
basit hale getirmeye yardımcı olur. Callback mekanizmalarına veya reaktif akışlara (reactive streams) kıyasla çok daha
kolay uygulanabilir ve yönetilebilir bir yapı sunar.
Aşağıdaki örnekte, coroutine'lerin nasıl basit ve okunaklı bir şekilde kullanıldığını görebiliriz:
fun onCreate() { viewModelScope.launch { val user = fetchUser() // coroutine askıya alınır (suspend) displayUser(user) // ana iş parçacığında (main thread) çalışır val posts = fetchPosts(user) // coroutine tekrar askıya alınır displayPosts(posts) // ana iş parçacığında çalışır } }
Bu kullanım kolaylığı, birden fazla asenkron işlemi gerçekleştirmemiz gerektiğinde özellikle belirgin hale gelir.
Asenkron işlemler, Kotlin Coroutines kütüphanesinin bir parçası olan async ve await fonksiyonlarıyla kolayca
yönetilebilir.
suspend fun fetchUser(): UserData = coroutineScope { val userDetails = async { api.fetchUserDetails() } val posts = async { api.fetchPosts() } UserData(userDetails.await(), posts.await()) }
Asenkron işlemler birbirleriyle kolayca birleştirilebilir. Örneğin, bir koleksiyondaki her öğe için asenkron bir işlem
başlatabilir ve tüm işlemlerin tamamlanmasını bekleyebiliriz.
suspend fun getUserArticleDetails( userId: String ): List<ArticleDetails> = coroutineScope { articleRepo.getArticles(userId) .filter { it.isPublic } .map { async { articleRepo.getArticleDetails(it.id) } } .awaitAll() }
Coroutines ayrıca, diğer kütüphanelerde bulunmayan eşzamanlama (synchronization) araçları sunar. Bunun yanı sıra,
yönetimi deneyimli bir geliştirici için basit ve sezgiseldir.

Performans

Kotlin Coroutines, yüksek verimlilik sağlamak için tasarlanmıştır. Hafif yapıları sayesinde büyük ölçekli sistemlerde
geniş çapta kullanılabilirler. Askıya alınan (suspend) fonksiyonlar Single4’dan çok daha hafif, Flow5
ise, Observable6’dan çok daha verimlidir. Askıya alınan fonksiyonların ve Flow yapısının nasıl çalıştığını
incelediğimizde, mümkün olan en basit ve en verimli yapıda olduklarını görebiliriz.
Coroutines, iş parçacıklarına (threads) kıyasla çok daha verimlidir çünkü iş parçacıkları yüksek bellek tüketimi
gerektirir ve başlatılması ile durdurulması maliyetlidir. Coroutines, iş parçacıkları üzerinde çalışan hafif bir
soyutlama katmanıdır. İş parçacıklarını en verimli şekilde kullanarak büyük ölçekli uygulamalarda kolayca
yönetilebilirler.
Bu durumu, 100.000 kullanıcının bir arka uç (backend) servisine veri talebi göndermesini simüle eden aşağıdaki kod
parçacıklarıyla açıklayabiliriz. İlk kod parçası, 100.000 iş parçacığını başlatarak bunları bir saniye
bekletmektedir (örneğin, bir veritabanı yanıtını beklemek gibi). Bu kod çalıştırıldığında, noktaların ekrana
yazdırılmasının zaman aldığı ve hatta sistemin OutOfMemoryError hatası verebileceği gözlemlenebilir. Bu, büyük ölçekli
iş parçacığı kullanımının getirdiği maliyettir.
İkinci kod parçası ise, iş parçacıkları yerine coroutines kullanıyor ve işlemleri askıya alarak bekletiyor . Bu kod
çalıştırıldığında, program bir saniye bekleyip ardından tüm noktaları ekrana yazdırmaktadır . Tüm bu coroutine
işlemlerini başlatmanın maliyeti o kadar düşüktür ki, neredeyse fark edilmez.
import kotlin.concurrent.thread fun main() { repeat(100_000) { thread { Thread.sleep(1000L) print(".") } } }
import kotlinx.coroutines.* fun main(): Unit = runBlocking { repeat(100_000) { launch { delay(1000L) print(".") } } }
Kotlin Coroutines her halükarda Java 21 ile sunulan Project Loom6'un sanal iş parçacıklarından daha hızlı
değildir, çünkü bu sanal iş parçacıkları da aslında kendi coroutine yapılarıyla çalışmaktadır. Ancak Kotlin Coroutines,
iptal mekanizmaları (cancellation) ve eşzamanlama (synchronization) gibi konularda ek verimlilik sağlayan birçok
gelişmiş araç
sunmaktadır.

İptal Mekanizması (Cancellation)

Kotlin Coroutines, zahmetsiz bir iptal mekanizması sunar. Bu durum, özellikle ön yüz (frontend) geliştirme
bağlamında büyük önem taşır, çünkü kullanıcı ekranı terk ettiğinde veya bir arayüz öğesi gizlendiğinde tüm işlemlerin
otomatik olarak iptal edilmesi gerekir. Coroutine'lerin iptal edilmesi , geri çağırma (callback) tabanlı API'ler veya
reaktif akışlar (reactive streams) ile kıyaslandığında oldukça basittir.
fun onCreate() { viewModelScope.launch { // Kullanıcı ekranı terk ettiğinde iptal edilir val news = getNewsFromApi() val sortedNews = news .sortedByDescending { it.publishedAt } view.showNews(sortedNews) } }
Arka uç (backend) geliştirme bağlamında, iptal mekanizmasının avantajları daha az görünür olsa da, yine de büyük
önem taşır. Örneğin, önceki bölümde ele alınan fetchUser fonksiyonunu düşünelim. Eğer fetchPosts başarısız olursa,
fetchUserDetails fonksiyonu hemen iptal edilir ve böylece sistem kaynakları serbest bırakılır. Bu, yapısal
eşzamanlılık (structured concurrency) ilkesinin bir sonucu olup Kotlin Coroutines tarafından tanıtılmıştır.
suspend fun fetchUser(): UserData = coroutineScope { // Eğer fetchPosts başarısız olursa, fetchUserDetails iptal edilir val userDetails = async { api.fetchUserDetails() } // Eğer fetchUserDetails başarısız olursa, fetchPosts iptal edilir val posts = async { api.fetchPosts() } UserData(userDetails.await(), posts.await()) }
İptal mekanizması, çoğu zaman doğrudan görünmese de, birçok farklı durumda büyük avantajlar sağlar. Örneğin, Ktor
sunucusu (coroutine tabanlı bir arka uç çerçevesi) üzerinde çalışan bir istemciyi ele alalım. Eğer bir istemci
sunucuya bir istek gönderip yanıtı beklemeden bağlantıyı kapatırsa, coroutine iptal mekanizması sayesinde sunucu,
isteği anında iptal ederek sistem kaynaklarını gereksiz yere tüketmekten kaçınabilir. Ancak, engelleyici (blocking) iş
parçacıkları kullanıldığında, sunucu genellikle isteğin tamamlanmasını beklemek zorunda kalır ve kaynaklar serbest
bırakılamaz. Bu avantaj, WebSockets veya RSocket gibi bağlantıların dinamik olarak kesilebildiği iletişim protokolleri
kullanan
sunucular için özellikle kritiktir. Kullanıcı bağlantıyı herhangi bir anda kesebileceğinden, coroutine'lerin sunduğu
otomatik iptal mekanizması, yüksek trafiğe sahip servislerde büyük bir verimlilik avantajı sağlar.
// Ktor sunucu örneği fun Route.messagesApi() { get("/message/statistics") { // HTTP bağlantısı kesildiğinde otomatik olarak iptal edilir val statistics = calculateMessageStatistics() call.respond(statistics) } rSocket("/message/channel") { RSocketRequestHandler { requestChannel { header, control -> // RSocket bağlantısı kesildiğinde otomatik olarak iptal edilir messagesFlow(header, control) } } } }

Eşzamanlama (Synchronization)

Kotlin Coroutines, eşzamanlı işlemleri senkronize etmek için çeşitli araçlar sunar. Değiştirilebilir (mutable) bir
duruma erişimi senkronize etmek ve çakışmaları önlemek istediğimizde, tek bir iş parçacığına (thread) sınırlı bir
dispatcher7 kullanabiliriz. Çoğu durumda, bu yaklaşım diğer senkronizasyon araçlarına kıyasla daha basit ve daha
averimlidir.
class UserDownloader( private val networkService: NetworkService ) { private val users = mutableListOf<User>() private val dispatcher = Dispatchers.IO.limitedParallelism(1) suspend fun downloaded(): List<User> = withContext(dispatcher) { users.toList() } suspend fun fetchUser(id: Int) = withContext(dispatcher) { val newUser = networkService.fetchUser(id) users += newUser } }
Eğer birden fazla asenkron işlemi başlatıp tamamlanmasını beklemek istiyorsak, supervisorScope gibi bir coroutine
scope fonksiyonunu kullanabiliriz. Yapısal eşzamanlılık (structured concurrency) sayesinde, alt
coroutine'lerin tamamlanmasını beklemek bu yapıya doğal olarak dahildir.
suspend fun process() { val updates = fetchUpdates() supervisorScope { updates.forEach { update -> launch { processUpdate(update) } } } println("Tüm güncellemeler işlendi") sendUpdatesProcessedNotification() }
Bunun yanı sıra, diğer senkronizasyon ihtiyaçları için Kotlin Coroutines içinde yerleşik birçok mekanizma
bulunmaktadır:
  • Bir coroutine'in başka bir coroutine'i beklemesi gerekiyorsa, Job nesnesi üzerinden join fonksiyonu
    kullanılabilir.
  • Bir coroutine tarafından üretilen değerin başka bir coroutine tarafından beklenmesi gerekiyorsa,
    CompletableDeferred kullanılabilir.
  • Coroutine'lerin güvenli bir şekilde veri alışverişi yapması gerekiyorsa, Channel kullanılabilir.
Bu araçların tamamı yerleşik (built-in) olarak gelir ve oldukça kolay kullanılabilir. Kotlin Coroutines'in sunduğu bu
senkronizasyon araçları sayesinde, eşzamanlı işlemler daha yönetilebilir ve verimli
hale gelmektedir.
class SomeService( private val scope: CoroutineScope ) { fun startTasks() { val job = scope.launch { // ... } scope.launch { // ... job.join() // ... } } }

Test Edilebilirlik (Testability)

Coroutines'in en büyük avantajlarından biri de test edilebilirliğidir. Kotlin Coroutines, sanal zaman (virtual
time)8 kullanarak çalışmayı destekler. Bu özellik sayesinde, diğer kütüphanelerle test edilmesi zor olan
senaryolar için hızlı, kesin ve belirleyici testler yazmak mümkündür. Örneğin, fetchUser fonksiyonunun gerçekten
kullanıcı bilgilerini ve gönderileri asenkron olarak çektiğini test etmek
istediğinizi varsayalım. Her işlemin bir saniye sürdüğünü simüle eden bir test yazarak, fonksiyonun toplamda tam olarak
bir saniye sürdüğünü doğrulayabilirsiniz. Bu tür bir test, sanal zaman sayesinde hızlı, kesin ve öngörülebilir olur.
@Test fun `should fetch data asynchronously`() = runTest { val api = mockk<Api> { coEvery { fetchUserDetails() } coAnswers { delay(1000) UserDetails("John Doe") } coEvery { fetchPosts() } coAnswers { delay(1000) listOf(Post("Hello, world!")) } } val useCase = FetchUserDataUseCase(api) val userData = useCase.fetchUser() assertEquals("John Doe", userData.user.name) assertEquals("Hello, world!", userData.posts.single().title) assertEquals(1000, currentTime) }
Sanal zaman, zaman aşımı (timeouts), tekrar deneme (retries) ve zamanla ilgili diğer işlemleri test etmeyi de mümkün
kılar. Ayrıca, farklı senaryoların nasıl işlediğini doğrulamamıza olanak tanır. Örneğin:
  • X, Y'den daha hızlı ancak Z'den daha yavaş olursa ne olur?
  • X, Z'den daha hızlı olursa nasıl bir sonuç alırız?
Tüm bu senaryoları kolayca simüle edip test etmek mümkündür. Kotlin Coroutines’in sunduğu test edilebilirlik
avantajlarından biri de budur.

Flow

Kotlin Coroutines, asenkron veri akışlarını ifade etmek ve işlemek için güçlü bir soyutlama sağlar. Bu soyutlama
Flow5 olarak adlandırılır. Flow, RxJava veya Reactor akışlarına kıyasla çok daha hafiftir ve uygulanması oldukça
basittir (ilerleyen bölümlerde yalnızca birkaç satır kod ile nasıl uygulanabileceğini göstereceğim). Ayrıca, birçok
kullanışlı operatörü içeren zengin bir özellik kümesine sahiptir.
fun notificationStatusFlow(): Flow<NotificationStatus> = notificationProvider.observeNotificationUpdate() .distinctUntilChanged() .scan(NotificationStatus()) { status, update -> status.applyNotification(update) } .combine( userStateProvider.userStateFlow() ) { status, user -> statusFactory.produce(status, user) }
Flow'lar SharedFlow ve StateFlow sayesinde sıcak akışlar (hot flows) olabilir. Bu mekanizmalar, olayların veya durum
değişikliklerinin birden fazla gözlemciye yayımlanmasına olanak tanır. Böylece, yalnızca bir gözlemcinin birden fazla
akış tarafından kullanılmasını sağlamak veya gözlemlenebilir bir değişken durumu temsil etmek mümkündür. Android
üzerinde, değiştirilebilir durumu temsil etmek için yaygın olarak kullanılan standart yöntem budur.
class NotificationProvider( notificationClient: NotificationClient, scope: CoroutineScope ) { private val notifications = notificationClient.observe() .shareIn( scope = scope, started = SharingStarted.WhileSubscribed(), ) fun observe(): Flow<Notification> = notifications }
// Android'de değiştirilebilir durumu temsil etme yöntemi class NewsViewModel : BaseViewModel() { private val _loading = MutableStateFlow(false) val loading: StateFlow<Boolean> = _loading private val _news = MutableStateFlow(emptyList<News>()) val news: StateFlow<List<News>> = _news fun onCreate() { newsFlow() .onStart { _loading.value = true } .onCompletion { _loading.value = false } .onEach { _news.value = it } .catch { _failure.value = it } .launchIn(viewModelScope) } }

Coroutines Çoklu Platform Desteğine Sahiptir

Kotlin Coroutines, tüm Kotlin hedeflerinde ve ortak modüllerde kolayca kullanılabilen bir çoklu platform (multiplatform)
kütüphanesidir. Bu evrensellik, çoklu platform projeleri veya kütüphaneleri yazarken büyük bir avantaj sağlar. Özellikle
ön yüz (frontend) tarafında çoklu platform bileşenlerinin popülaritesi artmaktadır, ancak bu avantaj arka uç (backend)
geliştirmede de etkili bir şekilde kullanılabilir. En önemlisi, birçok Kotlin kütüphanesi çoklu platform desteğine
sahiptir, bu sayede aynı kütüphane hem istemci tarafında hem de sunucu tarafında kullanılabilir. Bazı projelerde, aynı
kodu hem arka uçta hem de ön yüzde, hatta JavaScript üzerinde kullanabilmek için çoklu platform kütüphaneleri
tanımladım. Bu gibi durumlarda coroutines oldukça faydalı olmaktadır.

Kotlin Coroutines ile İlgili En Büyük Problem

Kotlin Coroutines ile ilgili en büyük problemin, karmaşık yapıları soyutlayarak gizlemeleri olduğuna
inanıyorum9. Eğer coroutines en iyi uygulamalara uygun bir şekilde veya detaylı bilgiyle kullanılıyorsa, bu
büyük bir avantajdır. Ancak, eğer coroutine'leri nasıl çalıştığını tam olarak anlamadan sıra dışı işlemler yapmaya
çalışırsanız, çeşitli problemlere yol açabilir. Örneğin, coroutine'lerin birbirini beklemesi veya yanlışlıkla iptal
etmesi gibi sorunlar ortaya çıkabilir. Bunun çözümü, coroutine'lerin nasıl çalıştığını anlamaktan geçer. Doğru soyutlama
seviyesini anladıktan sonra, coroutine'leri güvenli ve verimli bir şekilde kullanabilirsiniz. Eğitim burada kritik bir
rol oynamaktadır ve bu kitabı yazmamın ana nedeni de budur. Amacım, coroutine'lerin nasıl çalıştığını ve nasıl güvenli
ve verimli bir şekilde kullanılabileceğini anlatmaktır.

Sonuç

Kotlin Coroutines, asenkron kod yazmak için güçlü bir araçtır. Basit, verimli ve test edilebilir bir yapı sunar.
Senkronizasyon için birçok araç sağlar ve çoklu platform desteğine sahiptir. Hafif iş parçacıkları (lightweight threads)
değillerdir, ancak birçok farklı şekilde kullanılabilen güçlü bir soyutlamadır. Yeni başlayanlar için uygun olmalarına
rağmen, nasıl çalıştıklarını anlamadan kullanıldığında riskli olabilirler. Bu nedenle, kendinizi eğitmek çok önemlidir.
Bu kitabın, coroutine'lerin nasıl çalıştığını anlamanıza ve onları güvenli ve verimli bir şekilde nasıl kullanacağınızı
öğrenmenize yardımcı olacağını umuyorum.
  • Dispatchers.Default : CPU yoğun işlemler için optimize edilmiştir.
  • Dispatchers.IO : G/Ç ( I/O - Input/Output) işlemleri için uygundur.
  • Dispatchers.Main: UI işlemleri için kullanılır (Android'de yaygındır).
  • Dispatchers.Unconfined*: İlk çalıştığında mevcut iş parçacığını kullanır ancak daha sonra farklı bir iş parçacığına
    geçebilir.
  • Dispatchers.IO.limitedParallelism(1): Tek iş parçacığıx kullanarak coroutine’lerin sıralı çalışmasını sağlar ve
    senkronizasyon ihtiyacını azaltır.
  1. 1.Conway, Melvin E. (Temmuz 1963). “Design of a Separable Transition-diagram Compiler” (Ayrılabilir Geçiş ↩
  2. 2.Endüstri standardına uygun ve evrensel ilk coroutine’lerin 2009 yılında Go programlama dili tarafından ↩
  3. 3.Bu durum, coroutine kavramını doğru bir şekilde anlayıp etkin bir şekilde kullanmanın önemini ↩
  4. 4.Single: Tek bir değer üreten ve tamamlanan bir veri akışıdır. API çağrıları gibi tek seferlik işlemler ↩
  5. 5.Flow: Kotlin Coroutines içinde, reaktif veri akışlarını temsil eden bir yapıdır. Hafif ve geri basıncı ( ↩
  6. 6.Observable: RxJava’da çok sayıda veri yayabilen bir veri akışıdır. UI olayları ve sürekli veri akışlarında ↩
  7. 7.Dispatcher , coroutine'lerin hangi iş parçacığında ( thread ) çalışacağını belirleyen bir mekanizmadır. Farklı ↩
  8. 8.Sanal zaman (virtual time), coroutine tabanlı testlerde zamanla ilgili işlemleri hızlandırmak için ↩
  9. 9.Kotlin Coroutines, işlem zamanlaması, iptal mekanizmaları ve iş parçacıkları arasındaki görev geçişlerini ↩