
Bu metin, Kotlin Coroutines kitabının bir bölümüdür. Kitabın tamamına LeanPub üzerinden erişebilirsiniz
bundan çok daha fazlasıdır. 1963 yılında ilk kez tanımlanan bir kavramın1Conway, Melvin E. (Temmuz 1963). “Design of a Separable Transition-diagram Compiler” (Ayrılabilir Geçiş endüstriyel ölçekte uygulanabilir bir
versiyonunun geliştirilmesi uzun yıllar almıştır2Endüstri standardına uygun ve evrensel ilk coroutine’lerin 2009 yılında Go programlama dili tarafından.
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.
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ır3Bu durum, coroutine kavramını doğru bir şekilde anlayıp etkin bir şekilde kullanmanın önemini.
avantajları detaylı bir şekilde inceleyeceğiz.
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.
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.
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.
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 } }
Asenkron işlemler, Kotlin Coroutines kütüphanesinin bir parçası olan
async ve await fonksiyonlarıyla kolaycayönetilebilir.
suspend fun fetchUser(): UserData = coroutineScope { val userDetails = async { api.fetchUserDetails() } val posts = async { api.fetchPosts() } UserData(userDetails.await(), posts.await()) }
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() }
yönetimi deneyimli bir geliştirici için basit ve sezgiseldir.
geniş çapta kullanılabilirler. Askıya alınan (suspend) fonksiyonlar
Single4Single: Tek bir değer üreten ve tamamlanan bir veri akışıdır. API çağrıları gibi tek seferlik işlemler’dan çok daha hafif, Flow5Flow: Kotlin Coroutines içinde, reaktif veri akışlarını temsil eden bir yapıdır. Hafif ve geri basıncı (ise,
Observable6Observable: RxJava’da çok sayıda veri yayabilen bir veri akışıdır. UI olayları ve sürekli veri akışlarında’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.
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.
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çekliiş parçacığı kullanımının getirdiği maliyettir.
ç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(".") } } }
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.
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) } }
ö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ısaleş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()) }
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) } } } }
duruma erişimi senkronize etmek ve çakışmaları önlemek istediğimizde, tek bir iş parçacığına (thread) sınırlı bir
dispatcher7Dispatcher , coroutine'lerin hangi iş parçacığında ( thread ) çalışacağını belirleyen bir mekanizmadır. Farklı 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 } }
supervisorScope gibi bir coroutinescope 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() }
bulunmaktadır:
- Bir coroutine'in başka bir coroutine'i beklemesi gerekiyorsa,
Jobnesnesi üzerindenjoinfonksiyonu
kullanılabilir. - Bir coroutine tarafından üretilen değerin başka bir coroutine tarafından beklenmesi gerekiyorsa,
CompletableDeferredkullanılabilir. - Coroutine'lerin güvenli bir şekilde veri alışverişi yapması gerekiyorsa,
Channelkullanılabilir.
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() // ... } } }
time)8Sanal zaman (virtual time), coroutine tabanlı testlerde zamanla ilgili işlemleri hızlandırmak için 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çektenkullanı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) }
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?
avantajlarından biri de budur.
Flow5Flow: Kotlin Coroutines içinde, reaktif veri akışlarını temsil eden bir yapıdır. Hafif ve geri basıncı ( 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) }
SharedFlow ve StateFlow sayesinde sıcak akışlar (hot flows) olabilir. Bu mekanizmalar, olayların veya durumdeğ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) } }
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.
inanıyorum9Kotlin Coroutines, işlem zamanlaması, iptal mekanizmaları ve iş parçacıkları arasındaki görev geçişlerini. 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.
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.Conway, Melvin E. (Temmuz 1963). “Design of a Separable Transition-diagram Compiler” (Ayrılabilir Geçiş ↩
- 2.Endüstri standardına uygun ve evrensel ilk coroutine’lerin 2009 yılında Go programlama dili tarafından ↩
- 3.Bu durum, coroutine kavramını doğru bir şekilde anlayıp etkin bir şekilde kullanmanın önemini ↩
- 4.Single: Tek bir değer üreten ve tamamlanan bir veri akışıdır. API çağrıları gibi tek seferlik işlemler ↩
- 5.Flow: Kotlin Coroutines içinde, reaktif veri akışlarını temsil eden bir yapıdır. Hafif ve geri basıncı ( ↩
- 6.Observable: RxJava’da çok sayıda veri yayabilen bir veri akışıdır. UI olayları ve sürekli veri akışlarında ↩
- 7.Dispatcher , coroutine'lerin hangi iş parçacığında ( thread ) çalışacağını belirleyen bir mekanizmadır. Farklı ↩
- 8.Sanal zaman (virtual time), coroutine tabanlı testlerde zamanla ilgili işlemleri hızlandırmak için ↩
- 9.Kotlin Coroutines, işlem zamanlaması, iptal mekanizmaları ve iş parçacıkları arasındaki görev geçişlerini ↩