โครูทีนคืออะไร?

Coroutines ช่วยจัดการงานที่ใช้เวลานานซึ่งอาจบล็อกเธรดหลักและทำให้แอปของคุณไม่ตอบสนอง Coroutine เป็นรูปแบบการออกแบบพร้อมกันที่คุณสามารถใช้บน Android เพื่อลดความซับซ้อนของโค้ดที่ดำเนินการแบบอะซิงโครนัส

ดังที่คุณเห็นในแผนภาพด้านบน ในเธรดหลักของคุณ คุณสามารถดำเนินการเพียงเล็กน้อยเท่านั้น หากคุณต้องการดำเนินการเป็นเวลานานในเธรดหลักของคุณ แอปของคุณอาจขัดข้องและช้า หรือถ้าคุณสร้างไม่มี ของเธรดพื้นหลัง/ผู้ปฏิบัติงาน จากนั้นปัญหาหน่วยความจำไม่เพียงพอกำลังจะมา Coroutines เป็นฟังก์ชันประเภทพิเศษที่จงใจให้การควบคุมแก่ผู้เรียก แต่ไม่ได้ยุติบริบทในกระบวนการ แทนที่จะคงไว้ในสถานะว่าง

วิธีการใช้ Coroutines?

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:x.x.x"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:x.x.x"
}

• หลัก:ใช้เธรด UI ใน Rx จะคล้ายกับ AndroidSchedulers.MainThread()
• ค่าเริ่มต้น:ใช้สำหรับงาน ที่ใช้ CPU มาก มันจะใช้เธรดมากที่สุดเท่าที่แกน CPU มีอยู่ เนื่องจากเป็นงานที่ต้องใช้ CPU มาก จึงไม่มีประโยชน์ที่จะต้องรันเธรดจำนวนมาก เนื่องจาก CPU จะไม่ว่าง คล้ายกับ Schedulers.computation() ใน Rx
• IO:ใช้สำหรับ อินพุต/เอาต์พุต การร้องขอไปยัง API การเข้าถึงฐานข้อมูล ฯลฯ คล้ายกับ Schedulers.io() ใน Rx
• งาน:โดยพื้นฐานแล้วมันเป็นงานที่ทำงานอยู่เบื้องหลัง และสามารถตีความได้ว่าเป็นการกระทำ โดยมีวงจรชีวิตที่จะถูกทำลายเมื่อเสร็จสิ้น
• สำหรับการรันการดำเนินการต่างๆ โดยใช้งาน: Job.join
• สำหรับการยกเลิกงานย่อยทั้งหมด: Job.cancel
• withContext:อีกวิธีในการเขียน async โดยที่เราไม่ต้องเขียน wait()

suspend fun fetchUser() = withContext(Dispatchers.IO) {
        // make network call
        // return 
}

Suspend : ตามชื่อของมัน มันเป็นฟังก์ชันที่ระงับการดำเนินการของ coroutine ในบางจุด แล้วกลับมาดำเนินการของฟังก์ชันอีกครั้งเมื่อผลลัพธ์พร้อม

suspend fun makeNetworkRequest() {
    // fetchData is another suspend function, so 'makeNetworkRequest' is going to be `suspended`
    // until it's result becomes available, without blocking the main thread.
    val result = fetchData()
    // continues executing once the result becomes available
    show(result)
}

// fetchData is main thread safe
suspend fun fetchData(): Result { ... }

การเรียกใช้งานจะไม่บล็อกเธรดหลัก แต่ในทางกลับกัน การดำเนินการส่วนที่เหลือของโค้ดจะไม่รอผลการเปิดใช้ เนื่องจากการเรียกใช้งานไม่ใช่การระงับการโทร

fun GFG()
{
    var resultOne = "Android"
    var resultTwo = "Kotlin"
    Log.i("Launch", "Before")
    launch(Dispatchers.IO) { resultOne = function1() }
    launch(Dispatchers.IO) { resultTwo = function2() }
    Log.i("Launch", "After")
    val resultText = resultOne + resultTwo
    Log.i("Launch", resultText)
}

suspend fun function1(): String
{
    delay(1000L)
    val message = "function1"
    Log.i("Launch", message)
    return message
}

suspend fun function2(): String
{
    delay(100L)
    val message = "function2"
    Log.i("Launch", message)
    return message
}

Async ยังใช้เพื่อเริ่มต้น coroutines แต่จะบล็อกเธรดหลักที่จุดเข้าใช้งานของ ฟังก์ชัน wait()ในโปรแกรม

fun GFG
{
    Log.i("Async", "Before")
    val resultOne = Async(Dispatchers.IO) { function1() }
    val resultTwo = Async(Dispatchers.IO) { function2() }
    Log.i("Async", "After")
    val resultText = resultOne.await() + resultTwo.await()
    Log.i("Async", resultText)
}

suspend fun function1(): String
{
    delay(1000L)
    val message = "function1"
    Log.i("Async", message)
    return message
}

suspend fun function2(): String
{
    delay(100L)
    val message = "function2"
    Log.i("Async", message)
    return message
}

ประโยชน์ที่ได้รับจากการใช้ Coroutines

• Coroutines เป็นเส้นด้ายที่มีน้ำหนักเบา
• Coroutines สามารถทำงานแบบคู่ขนาน รอกันและกัน และสื่อสารกันได้
• สร้าง Coroutine นับพันโดยไม่มีปัญหาเรื่องหน่วยความจำ
• ดีที่สุดสำหรับการใช้งานสมัยใหม่