Giới thiệu về Coroutine trong Kotlin

Jan 17 2023

Coroutine là một luồng thực thi nhẹ có thể tạm dừng và tiếp tục lại sau. Đã có nhiều bài báo hoặc chủ đề đề cập đến vấn đề này nhưng bài đăng này thì khác, nó đơn giản và có thể giúp bạn bắt đầu dễ dàng hơn.

Tổng quan

Giống như nhiều ngôn ngữ lập trình khác như JS, Python, Coroutine là một tính năng được cung cấp bởi Kotlin cho phép chúng ta thực hiện các tác vụ dài và tốn thời gian. Nói ngắn gọn:

Trong Kotlin, Coroutines là một cách để viết mã không đồng bộ, không chặn theo cách tuần tự và dễ đọc hơn.

Trong thực tế, không có gì kỹ thuật mới ở đây. Chúng ta có thể coi Kotlin Coroutine như một khung/thư viện gói gọn một số cách sử dụng phổ biến trong khi xử lý quá trình không đồng bộ hóa.

Ví dụ đơn giản về sử dụng coroutines trong Kotlin

Để sử dụng coroutines trong Kotlin, bạn cần đưa kotlinx-coroutines-corethư viện vào dự án của mình. Trong tệp lớp ứng dụng của bạn (chỉ có một tệp lớp trong dự án IntelliJ hoặc chọn tệp lớp cho ứng dụng nếu đó là dự án Android), hãy thêm dòng sau:

dependencies {
    testImplementation(kotlin("test-junit"))
    implementation(kotlin("stdlib-jdk8"))
    // add coroutine dependency
    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.2")
}

1. Dùng `launch`để tạo coroutine

Đây là một ví dụ về việc sử dụng một coroutine để thực hiện một tác vụ dài hạn trong nền:

import kotlinx.coroutines.*

fun main() {
    // Start a coroutine using the launch function
    val job = GlobalScope.launch {
        // Perform a long-running task in the background
        delay(1000L)
        println("Hello, world!")
    }

    // Wait for the coroutine to finish
    runBlocking {
        job.join()
    }
}

2. Dùng `async`để tạo coroutine

Dưới đây là một ví dụ về việc sử dụng coroutines trong Kotlin để thực hiện song song nhiều tác vụ và sau đó đợi tất cả chúng hoàn thành:

import kotlinx.coroutines.*

fun main() {
    // Start two coroutines using the async function
    val job1 = GlobalScope.async {
        // Perform a long-running task in the background
        delay(1000L)
        println("Task 1")
    }

    val job2 = GlobalScope.async {
        // Perform a different long-running task in the background
        delay(2000L)
        println("Task 2")
    }

    // Wait for both coroutines to finish
    runBlocking {
        job1.await()
        job2.await()
    }
}

Sự khác biệt giữa khởi chạy và không đồng bộ để bắt đầu một coroutine

Cả hai đều thường được sử dụng để bắt đầu một coroutine. Sự khác biệt chính giữa hai loại này là launchtrả về một Công việc (một tương lai có thể hủy không bị chặn) và không trả về kết quả, trong khi asynctrả về một Bị hoãn (một tương lai có thể hủy không bị chặn có kết quả) có thể được sử dụng để lấy kết quả của quy trình. Xem xét sự khác biệt, khi nào nên sử dụng launch và async để tạo coroutine:

Khi bạn sử dụng launchhàm, coroutine sẽ chạy ngầm và lời gọi hàm sẽ trả về ngay lập tức. Nó được sử dụng khi kết quả của coroutine là không cần thiết.
Khi bạn sử dụng asynchàm, coroutine cũng sẽ chạy ẩn và lời gọi hàm sẽ trả về ngay lập tức, nhưng nó sẽ trả về một Deferredđối tượng mà bạn có thể gọi hàm .await() để lấy kết quả của coroutine. Nó được sử dụng khi kết quả của coroutine là cần thiết. Ví dụ:

val result = GlobalScope.async {
        return@async URL("https://api.example.com/data").readText()
    }
val data = result.await()
println(data)
// output: {"fact":"A group of cats is called a \u201cclowder.\u201d","length":38}

Còn gì nữa từ đây? Như chúng ta đã biết Coroutine là một chủ đề lớn và ít người có thể giải thích tất cả về nó. Đây là bài viết đầu tiên của loạt Coroutine. Nếu bạn quan tâm, vui lòng đăng ký để biết thêm các bài viết tiếp theo về điều này: