async: یہ کیا ہے، Deferred اور متوازی کوروٹینز کیسے کام کرتے ہیں

Kotlin Coroutines میں async کیا ہے؟

async — CoroutineScope کا ایک اڤسٹنشن فنکشن ہے جو نتیجہ واپس کرنے والا کوروٹین تیار کرتا ہے۔ launch کے برعکس، async Deferred<T> واپس کرتا ہے — ایک آبجیکٹ جو مستقبل کی قیمت کی نمائندگی کرتا ہے۔ async کے ذریعے شروع کیا گیا ایک کوروٹین دوسرے کوروٹینز کے ساتھ ہم زمان چلتا ہے، حساب کاریاں کو متوازی کرنے کی اجازت دیتا ہے۔

async استعمال ہوتا ہے جب ایک غیر ہم زمان آپریشن کا نتیجہ مزید پروسینگ کے لیے ضروری ہوتا ہے: متعدد ذرائع سے ڈیٹا لوڈ کرنا، کلکشنز کی بیچ پروسینگ، مختلف API کو متوازی درخواستیں۔ Deferred فوری تیار ہوتا ہے، اور کوروٹین مکمل ہونے کے بعد نتیجہ دستیاب ہوتا ہے۔

import kotlinx.coroutines.*

suspend fun String.delayedValue(): String {
    delay(1000L)
    return this
}

fun main() = runBlocking {
    val deferred: Deferred<String> = async { "Hello".delayedValue() }
    println(deferred.await())
}

async اور Deferred کا سین ٹیکس

async کا دستخط launch کے مشابہ ہے: وہی CoroutineContext، CoroutineStart پیرامیٹر اور ایک suspend بلاک۔ فرق واپسی قیمت کی قسم میں ہے — Job کے بجاے Deferred<T>، جہاں T بلاک کے آخری ایکسپریشن سے واپس کیا گیا نتیجہ کی قسم ہے۔

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>

Deferred<T> — ایک اینٹرفیس جو Job سے وراستہ حاصل کرتا ہے اور await()، getCompleted()، getCompletionExceptionOrNull() میٹہڈ شامل کرتا ہے۔ await() ایک suspend فنکشن ہے اور صرف کوروٹین یا کسی دوسرے suspend فنکشن کے اندر بلایا جا سکتا ہے۔ getCompleted() ایک غیر منصرف کرنے والا میٹہڈ ہے جو اگر کوروٹین ابھی مکمل نہیں ہوئی تو استثنا پھینکتا ہے۔

async کے ساتھ متوازی کام

async کا بیڑا فائدہ کاموں کو متوازی چلانے کی صلاحیت ہے۔ هر آپریشن کے لیے ایک تور پر انتظار کرنے کے بجائے (کل وقت = اوقات کا مجموعہ)، async کوروٹینز کو بایک ساتھ شروع کرتا ہے، کل وقت کو سب سے طویل آپریشن کی میاد تک کم کرتا ہے۔

متوازی ڈیٹا لوڈینگ

ایک طریقی منظرنامہ — تین متوازی async درخواستوں کے ساتھ صارف کا پروفائل، ان کی ترتیبات اور آرڈر ہسٹری لوڈ کرنا۔ تینوں کے مکمل ہونے کے بعد، نتائج ایک واحد ڈیٹا ماڈل میں ملا دیئے جاتے ہیں۔

suspend fun loadUserDashboard(userId: String): Dashboard = coroutineScope {
    val profile = async { api.getProfile(userId) }
    val settings = async { api.getSettings(userId) }
    val orders = async { api.getRecentOrders(userId) }

    Dashboard(
        profile = profile.await(),
        settings = settings.await(),
        orders = orders.await()
    )
}

coroutineScope فنکشن چائلڈ کوروٹینز شروع کرتا ہے اور نتیجہ واپس کرنے سے پہلے ان کے مکمل ہونے کا انتظار کرتا ہے۔ پورا بلاک ایک تور پر نہیں، بلکہ متوازی چلتا ہے۔

Deferred نتائج کی پروسینگ

Deferred نتیجے کے ساتھ کام کرنے کے لیے متعدد میٹہڈ کی حمایت کرتا ہے۔ await() کے علاوہ، حالت چےک کرنے، مکمل قیمت حاصل کرنے اور Kotlin Coroutines کے مفید فنکشنز کے ذریعے متعدد Deferred کو اکٹھا کرنے کے میٹہڈ موجود ہیں۔

Deferred کی فہرست کو اکٹھا کرنے کے لیے، awaitAll() استعمال ہوتا ہے — ایک فنکشن جو کلکشن میں تمام Deferred کے مکمل ہونے تک عمل کو موقوف کرتا ہے۔ اگر کم سے کم ایک Deferred ناکام ہوتا ہے، تو awaitAll() استثنا پھینکتا ہے۔

suspend fun <T> loadAll(requests: List<suspend () -> T>): List<T> {
    return coroutineScope {
        val deferreds = requests.map { async { it() } }
        deferreds.awaitAll()
    }
}

async اور launch میں فرق

async اور launch کے درمیان انتخاب اس بات پر منحصر ہے کہ کوروٹین کا نتیجہ ضروری ہے یا نہیں۔ launch Job واپس کرتا ہے اور fire-and-forget آپریشنز کے لیے موزوں ہے، async Deferred واپس کرتا ہے اور ڈیٹا واپس کرنے والے کاموں کے لیے استعمال ہوتا ہے۔ سین ٹیکس اور پیرامیٹرز کے لحاظ سے، بلڈر ایک جیسے ہیں۔

• launch → Job (کوئی نتیجہ نہیں)، async → Deferred<T> (نتیجہ T)
• launch — fire-and-forget کام (لاگنگ، کیشنگ، اینالیٹکس بھیجنا)
• async — متوازی حساب (متعدد API سے لوڈنگ، بیچ پروسینگ)
• دونوں ساختاری ہم زمانیت اور CoroutineStart پیرامیٹرز کی حمایت کرتے ہیں
• await() صرف Deferred کے لیے دستیاب ہے، launch نتیجہ فراہم نہیں کرتا

اہم قاعدہ: fire-and-forget کے لیے async کا استعمال کبھی نہ کریں۔ اگر کوروٹین کا نتیجہ ضروری نہیں ہے، تو launch استعمال کریں۔ async Deferred بنانے کا اوورہیڈ پیدا کرتا ہے، جو ایسے مناظر میں جائز نہیں ہے۔

موبائل ڈیولپمنٹ میں async کی مثالیں

Android میں، async ViewModel اور UseCases کے اندر متوازی آپریشنز کے لیے استعمال ہوتا ہے۔ طریقی مناظر: ایک ساتھ پروفائل اور نیوز فیڈ لوڈ کرنا، متعدد موسم کی سروسوں سے موسم حاصل کرنا، سرور کے ساتھ بیچ ڈیٹا سنکرونائیزیشن۔

class HomeViewModel : ViewModel() {
    fun loadHomeScreen() {
        viewModelScope.launch {
            val userData = async(Dispatchers.IO) { repository.getUserData() }
            val newsFeed = async(Dispatchers.IO) { repository.getNewsFeed() }
            val notifications = async(Dispatchers.IO) { repository.getNotifications() }

            val state = HomeState(
                user = userData.await(),
                news = newsFeed.await(),
                unread = notifications.await()
            )
            _uiState.update { state }
        }
    }
}

غلطی کی علاوہگی کے لیے async کے ایک گروپ کو coroutineScope یا supervisorScope میں لپیٹنے کی سفارش کی جاتی ہے۔ supervisorScope باقی async کوروٹینز کو ایک کے ناکام ہونے پر بھی جاری رکھنے کی اجازت دیتا ہے — غیر اہم آپریشنز کے لیے مفید۔