Async/Await: öz, async fonksiyonları ve await ile çalışma

Async/Await ve Eşzamansız Programlama Nedir?

Async/Await, eşzamansız kodu senkron kod kadar doğrusal bir şekilde yazmanızı sağlayan bir dil yapısıdır. Swift'te, iOS 13 / macOS 10.15 ile Swift Concurrency çerçevesiyle birlikte geldi. Kotlin'de async/await, sürüm 1.3'ten itibaren eşyordam kütüphanesi (kotlinx.coroutines) aracılığıyla kullanılabilir.

async/await'ten önce, eşzamansız kod callback'ler, GCD veya RxSwift üzerine inşa ediliyordu. İç içe geçmiş callback zincirleri, okumayı ve hata ayıklamayı zorlaştıran derin bir iç içe geçme olan callback cehennemine yol açtı. Async/Await, eşzamansız fonksiyonların await noktalarında “askıya alınmas”na ve sonuç alındıktan sonra devam etmesine izin vererek bu sorunu çözer.

Google'a göre (2025), Kotlin'de async/await kullanmak, callback yaklaşımına kıyasla eşzamansız kod satırlarını %40–60 oranında azaltır. Swift'te, Swift Concurrency benimseme oranı 2025'te yayınlanan uygulamalar arasında %68'e ulaştı. iOS 16, UIKit, SwiftUI ve Foundation'a Swift Concurrency desteği ekleyerek async/await'i tüm yeni Apple projeleri için standart araç haline getirdi.

Çalışma Prensibi: Askıya Alınabilir Fonksiyonlar

async/await ile iş parçacıkları arasındaki temel fark, engelleme olmadan askıya almadır. Bir fonksiyon await ile karşılaştığında askıya alınır ve mevcut iş parçacığını diğer görevler için serbest bırakır. Eşzamansız işlem tamamlandıktan sonra, fonksiyon aynı veya farklı bir iş parçacığında devam eder. Buna işbirlikçi çoklu görev denir.

Async/Await Nasıl Çalışır: Askıya Alma ve Devam Ettirme

Bir async fonksiyonu, bir durum makinesine derlenir — yürütme durumlarını yöneten sonlu bir otomat. await noktasında, derleyici bağlamı (yerel değişkenler, dönüş adresi) kaydeder ve kontrolü çalışma zamanına devreder. Sonuç hazır olduğunda, çalışma zamanı bağlamı geri yükler ve yürütmeye devam eder.

Swift'te bu durum makinesi, SIL (Swift Intermediate Language) derleyici seviyesinde uygulanır. Kotlin'de Continuation Passing Style (CPS) mekanizması kullanılır: her suspend fonksiyonu, sonucun döndürüldüğü gizli bir Continuation parametresi alır. Her iki yaklaşım da bellek sızıntısı olmadan güvenli devam etmeyi garanti eder.

• Swift — derleyici async fonksiyonunu runAsync eşyordam çerçevesiyle SIL'e çevirir
• Kotlin — her suspend fonksiyonu bir Continuation alır ve yürütmeyi dağıtıcıya devreder
• Her iki dil — await'te iş parçacığını serbest bırakır, bekleme sırasında engellemez
• İstisnalar — standart mekanizmalar (throws / try-catch) aracılığıyla yayılır

Async/Await vs Callback'ler ve GCD: Yaklaşım Karşılaştırması

Callback yaklaşımı, işlem tamamlandıktan sonra çağrılan bir closure geçirmeyi gerektirir. Üç sıralı istekle, her seviyede hata yönetimiyle üç seviyeli iç içe geçme elde edilir. Async/Await aynı üç isteği, tek bir catch bloğuyla üç sıralı satıra dönüştürür.

GCD (DispatchQueue), seri kuyruklar ve DispatchGroup aracılığıyla callback cehennemini çözer ancak yine de ayrıntılıdır. Basit bir görev için — kullanıcı yükle, sonra arkadaşlar, sonra arayüz — kuyruklar, gruplar ve notify blokları gerekir. Async/Await aynı görevi tek bir fonksiyonda üç satırla gerçekleştirir.

Apple WWDC 2024'e göre, Swift Concurrency async/await yeni kod için önerilen yaklaşımdır. GCD, C kütüphaneleriyle entegrasyon ve belirli düşük seviyeli iş parçacığı işleme senaryoları için kalır.

Swift Concurrency: Task, TaskGroup ve Actor

Task, Swift'te eşzamansız çalışmanın temel birimidir. Bir Task, mevcut bir aktör bağlamında veya herhangi bir iş parçacığında oluşturulur. Bir Task içinde, await aracılığıyla async fonksiyonlar çağrılabilir. TaskGroup birden çok alt görevi paralel olarak başlatmaya ve sonuçlarını toplamaya olanak tanır — bu, DispatchGroup'un gelişmiş bir sürümüdür.

Actor, durumunu veri yarışlarından koruyan iş parçacığı güvenli bir referans türüdür. Derleyici, aktör özelliklerine erişimin yalnızca async çağrılar veya aktör yalıtımı içinde mümkün olduğunu garanti eder. Actor, manuel kilitler olmadan paylaşılan değişebilir durumu korumak için seri DispatchQueue'un yerini alır.

Structured Concurrency

Structured Concurrency ilkesi şunları belirtir: her eşzamansız görevin bir ebeveyni vardır ve ebeveyn, tüm çocukları tamamlanana kadar tamamlanmaz. Görev A, Task { await B() } başlatırsa, A, B'yi bekler. Bu, görev sızıntılarını önler ve öngörülebilir bir yaşam döngüsü sağlar.

Kotlin'de Eşyordamlarla Async/Await

Kotlin'de async/await, eşyordamlar (coroutines) aracılığıyla uygulanır — dilin hafif iş parçacıkları. Bir fonksiyon suspend anahtar kelimesiyle işaretlenir (Swift'teki async'in benzeri). Başlatmak için launch (ateşle ve unut) veya async (sonuçlu) kullanılır. Async'den sonuç almak için Await çağrılır.

Dispatcher, eşyordamın hangi iş parçacığı havuzunda çalıştırılacağını belirler: kullanıcı arayüzü için Dispatchers.Main, ağ/disk için Dispatchers.IO ve CPU yoğun görevler için Dispatchers.Default. Structured Concurrency, CoroutineScope aracılığıyla sağlanır — kapsam iptal edildiğinde tüm alt eşyordamlar iptal edilir.

JetBrains'e göre (2025), Google Play'deki Android uygulamalarının %97'si kotlinx.coroutines kullanıyor ve bunların %82'si ağ istekleri için async/await kullanıyor. Eşyordamlar, Android'de eşzamansız programlama için fiili standart haline geldi. Kotlin Multiplatform da eşyordamları destekleyerek Android, iOS ve sunucu tarafında paylaşılan eşzamansız kod kullanımına olanak tanır.

Swift ve Kotlin'de Async/Await ile Kod Örnekleri

Her dil için iki örneğe bakalım: sıralı veri yükleme ve TaskGroup veya async/await ile paralel istekler.

Swift: Sıralı async çağrılar

await, kullanıcı verileri alınana kadar, ardından arkadaşlar alınana kadar yürütmeyi askıya alır. İç içe closure yok.

func loadProfile() async throws -> Profile {
    let user = try await api.fetchUser()
    let friends = try await api.fetchFriends(for: user.id)
    return Profile(user: user, friends: friends)
}

Swift: TaskGroup ile Paralel İstekler

TaskGroup görevleri paralel olarak başlatır ve sonuçları bir dizide toplar. Sonuçların sırası, başlatma sırasıyla eşleşmeyebilir.

func loadParallel() async throws -> [String] {
    await withThrowingTaskGroup(of: String.self) { group in
        group.addTask { try await api.fetchName() }
        group.addTask { try await api.fetchEmail() }
        group.addTask { try await api.fetchAvatar() }
        var results = [String]()
        for try await value in group { results.append(value) }
        return results
    }
}

Kotlin: async/await ile Sıralı Çağrı

suspend fonksiyonları diğer suspend fonksiyonları çağırabilir. Swift'e benzer: sıralı çağrılar.

suspend fun loadProfile(): Profile {
    val user = api.fetchUser()
    val friends = api.fetchFriends(user.id)
    return Profile(user, friends)
}

Kotlin: async/await ile Paralel İstekler

Kotlin'de paralellik, her istek için async ile coroutineScope aracılığıyla elde edilir.

suspend fun loadParallel(): List<String> = coroutineScope {
    val name = async { api.fetchName() }
    val email = async { api.fetchEmail() }
    val avatar = async { api.fetchAvatar() }
    listOf(name.await(), email.await(), avatar.await())
}

Async/Await'in Yaygın Hataları ve Sınırlamaları

Unutulan Task { } — bir async fonksiyonu, Task içine sarılmadan senkron bir bağlamdan çağrılamaz. Swift'te bu, hata ile derlenir. Kotlin'de lifecycleScope veya viewModelScope aracılığıyla başlatma gerekir. Normal bir fonksiyondan suspend fonksiyonu çağırma girişimi derlenmeyecektir.

Gereksiz yere aşırı async kullanımı

Her fonksiyonun eşzamansız olması gerekmez. G/Ç'siz CPU yoğun görevler async'ten yararlanmaz — bunları .userInitiated QoS ile DispatchQueue'da yürütmek daha iyidir. Async/Await, G/Ç bağlantılı işlemler için optimize edilmiştir: ağ, disk, bekleme.

.result ile ana iş parçacığını engelleme

Ana iş parçacığında .result kullanmak (bir async fonksiyonunun sonucunu senkron olarak beklemek) engellemeye yol açar. Swift'te, Task.synchronousWait Apple tarafından önerilmez. Kotlin'de ana iş parçacığında runBlocking bir anti-örnektir — lifecycleScope kullanın.

İptalde Task sızıntısı

Bir Task bir sınıf özelliğinde saklanmazsa, bağlamdan çıkıldıktan sonra iptal edilir. Swift'te Task kapsamlıdır — yaşam döngüsü oluşturma bağlamına bağlıdır. Uzun süren bir işlem gerekiyorsa Task'i bir özellikte saklayın.