coroutines là gì?

Coroutines giúp quản lý các tác vụ chạy dài có thể chặn luồng chính và khiến ứng dụng của bạn không phản hồi. Coroutine là một mẫu thiết kế đồng thời mà bạn có thể sử dụng trên Android để đơn giản hóa mã thực thi không đồng bộ.

Như bạn thấy trong sơ đồ trên, trong luồng chính của bạn, bạn chỉ có thể thực hiện các thao tác nhỏ. Nếu bạn muốn thực hiện các hoạt động chạy dài trong luồng chính của mình thì ứng dụng của bạn có thể gặp sự cố và chậm. Hoặc nếu bạn tạo không. của luồng nền/công nhân thì vấn đề hết bộ nhớ sắp xảy ra. Coroutines là một loại chức năng đặc biệt cố tình trao quyền kiểm soát cho người gọi, nhưng không kết thúc ngữ cảnh của nó trong quy trình, thay vào đó duy trì nó ở trạng thái không hoạt động.

Làm thế nào để sử dụng Coroutines?

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

• Chính: sử dụng Chủ đề giao diện người dùng. Trong Rx tương tự như AndroidSchedulers.MainThread()
• Mặc định: được sử dụng cho các tác vụ sử dụng nhiều CPU . Nó sẽ sử dụng nhiều luồng như số lõi CPU có sẵn. Vì chúng là các tác vụ sử dụng nhiều CPU, nên không có ích gì khi có nhiều luồng chạy, vì CPU sẽ bận rộn. Tương tự như Schedulers.computation() trong Rx.
• IO: dùng cho Đầu vào/Đầu ra. Yêu cầu API, truy cập DB, v.v. Tương tự như Schedulers.io() trong Rx.
• Công việc: Về cơ bản, đây là một tác vụ chạy trong nền và có thể được hiểu là một hành động, với vòng đời sẽ bị hủy sau khi hoàn thành.
• Để chạy các hoạt động khác nhau bằng công việc: Job.join
• Để hủy bỏ tất cả các công việc con: Job.cancel
• withContext: một cách khác để viết async mà chúng ta không phải viết await().

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

Tạm dừng : Như tên gọi của chúng, chúng là các hàm tạm dừng việc thực thi quy trình đăng ký tại một thời điểm nào đó, sau đó tiếp tục thực hiện lại chức năng khi kết quả đã sẵn sàng.

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 { ... }

Khởi chạy sẽ không chặn luồng chính, nhưng mặt khác, việc thực thi phần còn lại của mã sẽ không đợi kết quả khởi chạy vì khởi chạy không phải là một cuộc gọi tạm dừng.

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 cũng được sử dụng để khởi động các coroutines, nhưng nó chặn luồng chính tại điểm vào của hàm await() trong chương trình.

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
}

Lợi ích khi sử dụng Coroutines

• Coroutines là chủ đề trọng lượng nhẹ
• Các coroutine có thể chạy song song, đợi nhau và giao tiếp với nhau
• Tạo hàng nghìn coroutine mà không gặp vấn đề về bộ nhớ
• Tốt nhất cho các ứng dụng hiện đại