Giới thiệu về Kotlin Coroutines trên JVM

Bài tutorial này sẽ hướng dẫn các bạn setup một project cho phép sử dụng coroutine và một đoạn code nho nhỏ minh họa cách sử dụng nó.

Trong phiên bản 1.1 thì Kotlin đã giới thiệu coroutine, một cách thức mới để viết code bất đồng bộ, non-blocking (và nhiều hơn thế nữa). Trong bài tutorial này thì chúng ta sẽ đi qua các cách sử dụng coroutine cơ bản với sự trợ giúp của thư viện kotlin.coroutine, đây là thư viện tập hợp các lớp helpers và wrappers cho các thư viện Java hiện tại.

Khởi tạo project

Trong bài tut mình sẽ sử dụng IntelliJ IDEA, một IDE khá thịnh hành của JetBrains - cũng chính là cha đẻ của Kotlin. Đây là một IDE yêu thích của mình, những ai muốn trải nghiệm thử thì có thể tải bản miễn phí là Community tại đây: https://www.jetbrains.com/idea/download/

Với project sử dụng Gradle

Trong IntelliJ IDEA vào File -> New -> Project:

Sau khi tạo xong project mới thì chúng ta sẽ có một file build.gradle được cấu hình sẵn cho việc sử dụng Kotlin được tạo ra. Do chúng ta sẽ sử dụng coroutine nên hãy chắc chắn rằng nó được cấu hình cho Kotlin 1.1 hoặc cao hơn.

Do coroutine vẫn đang ở chế độ thử nghiệm trong Kotlin 1.1, 1.2 nên mặc định trình biên dịch sẽ đưa ra cảnh báo cho mỗi lần nó được sử dụng. Nếu chúng ta muốn sử dụng bản thử nghiệm này và loại bỏ cảnh báo thì sẽ phải thêm các dòng này vào build.gralde:

apply plugin: 'kotlin'

kotlin {
    experimental {
        coroutines 'enables'
    }
}

Chúng ta sẽ sủ dụng kotlin.coroutines nên hãy nhớ cho nó vào dependencies, phiên bản mới nhất nhé:

dependencies {
    ...
    compile "org.jetbrains.kotlinx:kotlinx-coroutines-core:0.21"
}

Thư viện này được published trên Bintray JCenter nên chúng ta phải thêm nó vào repositories:

repositories {
    jcenter()
}

Và bây giờ chúng ta đã sẵn sàng để viết code ở src/main/kotlin

My first coroutine

Chúng ta có thể coi coroutine như là một light-weight thread. Cũng tương tự như thread thông thường thì coroutine có thể chạy song song hoặc chờ và giao tiếp với nhau. Một khác biệt lớn của coroutine so với thread là chi phí về mặt performance của nó rất rẻ mạt: Chúng ta có thể tạo hàng nghìn coroutine nhưng tác động của nó lên performance là rất thấp. Mặt khác thì các thread thông thường có chi phí về mặt performance rất đắt đỏ ở khâu start và duy trì chúng. Một nghìn thread sẽ là một thách thức không hề nhỏ kể cả đối với chiếc máy tính đời mới nhất.

Để start một coroutine thì chúng ta sẽ dùng hàm launch{}

launch {
	...
}

Hàm này sẽ start một coroutine mới. Mặc định thì các coroutine sẽ chạy trên một thread pool được chia sẻ. Threads vẫn tồn tại trong các chương trình sử dụng coroutine. Nhưng do 1 thread có thể chạy được nhiều coroutine nên việc tạo nhiều thread giờ đây sẽ là không cần thiết.

Hãy cùng xem qua một đoạn code sử dụng launch:

import kotlinx.coroutines.experimental.*

fun main(args: Array<String>) {
    println("Start")

    // Start a coroutine
    launch {
        delay(1000)
        println("Hello")
    }

    Thread.sleep(2000) // wait for 2 seconds
    println("Stop")
}

Ở đây thì chúng ta sẽ start một coroutine. Coroutine này sẽ chờ 1 giây và in ra dòng Hello.

Hàm delay ở đây tương tự như Thread.sleep() nhưng có ưu điểm sau: nó không block thread chạy nó mà chỉ tạm dừng coroutine gọi nó, thread được trả về pool trong khi coroutine vẫn đang chờ. Sau khi việc chờ đợi kết thúc thì coroutine sẽ được tiếp tục trên trên một thread đang rảnh trong pool.

Thread chính (là thread chạy hàm main()) sẽ phải chờ cho đến khi coroutine kết thúc, nếu không thì chương trình sẽ kết thúc trước khi dòng Hello được in ra. Không tin thì các bạn thử bỏ dòng Thread.sleep(2000)xem