async: มันคืออะไร, Deferred และโครอูตินแบบขนานานทำงานอย่างไร

async ใน Kotlin Coroutines คืออะไร?

async — เป็นฟังก์ชันส่วนขยายของ CoroutineScope ที่สร้าง coroutine และส่งคืนผลลัพธ์ ต่างจาก launch, async ส่งคืน Deferred<T> — อ็อบเจ็กต์ที่แทนค่าในอนาคต Coroutine ที่เริ่มผ่าน async ทำงานพร้อมกับ coroutine อื่น ช่วยให้สามารถทำงานคำนวณแบบขนานานได้

async ถูกใช้เมื่อต้องการผลลัพธ์ของการทำงานแบบไม่ชิงครอบครังสำหรับการประมวลผลต่อ: โหลดข้อมูลจากหลายแหล่ง, การประมวลผลทีละชุดของคอแลกชัน, การร้องขอแบบขนานานไปยัง API ต่าง ๆ Deferred ถูกสร้างทันที และผลลัพธ์จะพร้อมใช้งานหลังจาก coroutine สิ้นสุด

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 ความแตกต่างอยู่ที่ชนิดของค่าที่ส่งคืน — Deferred<T> แทน Job, โดย 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 และสามารถเรียกได้ภายใน coroutine หรือฟังก์ชัน suspend อื่น getCompleted() เป็นเมธอดที่ไม่บล็อก ซึ่งจะเกิดข้อยกเว้นหาก coroutine ยังไม่สิ้นสุด

งานแบบขนานานกับ async

ข้อดีหลักของ async คือความสามารถในการทำงานแบบขนานาน แทนที่จะรอแต่ละการทำงานเรียงลำดับ (เวลารวม = ผลรวมของเวลา), async เริ่ม coroutine พร้อมกัน ทำให้เวลารวมลดลงเป็นเวลาของ การทำงานที่ยาวที่สุด

การโหลดข้อมูลแบบขนานาน

สถานการณ์ทั่วไป — โหลดโปรไฟล์ผู้ใช้, การตั้งค่า และประวัติคำสั่งซื้อด้วยคำขอ 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 เริ่ม coroutine ย่อย และรอให้มันสิ้นสุดก่อนจะส่งคืนผลลัพธ์ บล็อกทั้งหมดทำงานแบบขนานาน, ไม่ใช่เรียงลำดับ

การจัดการผลลัพธ์ Deferred

Deferred รองรับหลายเมธอดในการทำงานกับผลลัพธ์ นอกเหนือจาก await() แล้ว ยังมีเมธอดสำหรับตรวจสอบสถานะ, รับค่าที่สิ้นสุด และรวมหลาย Deferred ผ่านฟังก์ชันอำนวยความสะดวกของ Kotlin Coroutines

สำหรับการรวมรายการ Deferred awaitAll() ถูกใช้ — ฟังก์ชันที่หยุดการทำงานไว้ชั่วคราวจนกว่า 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 ขึ้นอยู่กับว่าต้องการผลลัพธ์ของ coroutine หรือไม่ launch ส่งคืน Job และเหมาะสำหรับงาน fire-and-forget async ส่งคืน Deferred และใช้สำหรับงานที่ส่งคืนข้อมูล ในแง่ของไวยาการณ์และพารามิเตอร์ ตัวสร้างทั้งสองเหมือนกัน

• launch → Job (ไม่มีผลลัพธ์), async → Deferred<T> (ผลลัพธ์ T)
• launch — งาน fire-and-forget (การบันทึก, แคปช์, การส่งข้อมูลวิเคราะห์)
• async — การคำนวณแบบขนานาน (โหลดจากหลาย API, การประมวลผลทีละชุด)
• ทั้งสองรองรับ การทำงานพร้อมกันแบบมีโครงสร้าง และพารามิเตอร์ CoroutineStart
• await() ใช้ได้เฉพาะ Deferred, launch ไม่ให้ผลลัพธ์

กฎที่สำคัญ: อย่าใช้ async สำหรับ fire-and-forget หากไม่ต้องการผลลัพธ์ของ coroutine ให้ใช้ 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 ช่วยให้ coroutine async อื่นสามารถทำงานต่อไปได้แม้ว่าหนึ่งจะล้มเหลว — มีประโยชน์สำหรับงานที่ไม่สำคัญ