Coroutines là gì
Về cơ bản, coroutines là những thread nhẹ. Nó cho phép chúng ta viết mã bất đồng bộ.
Làm cách nào để import Corlinines trong Android?
Theo repo của Kotlin Coroutines Github, chúng ta cần nhập kotlinx-coroutines-core và kotlinx-coroutines-android (Thư viện này hỗ trợ cho luồng chính của Android giống như thư viện io.reactivex.rxjava2: rxandroid các ngoại lệ chưa được lưu có thể được ghi lại trước khi làm crassh ứng dụng Android.). Hơn nữa, nếu bạn sử dụng RxJava trong dự án của mình, vui lòng thêm kotlinx-coroutines-rx2 để sử dụng coroutines với RxJava. Thư viện này giúp chuyển RxJava sang Coroutines.
Nhập chúng vào dự án của bạn bằng cách thêm mã sau vào app / build.gradle.
1 2 3 4 | implementation 'org.jetbrains.kotlinx: kotlinx-coroutines-core: 1.3.2' implementation 'org.jetbrains.kotlinx: kotlinx-coroutines-android: 1.3.2' implementation "org.jetbrains.kotlinx: kotlinx-coroutines-rx2: 1.3.2" |
và thêm phiên bản Kotlin mới nhất vào root / build.gradle của bạn.
1 2 3 4 5 6 7 8 9 | buildscript { ext.kotlin_version = '1.3.50' repositories { jcenter() ... } ... } |
Coroutines cơ bản
Đầu tiên, Coroutines về cơ bản trông giống như thế này:
1 2 3 4 5 6 7 8 9 | CoroutineScope(Dispatchers.Main + Job()).launch { val user = fetchUser() // A suspending function running in the I/O thread. updateUser(user) // Updates UI in the main thread. } private suspend fun fetchUser(): User = withContext(Dispatchers.IO) { // Fetches the data from server and returns user data. } |
Chúng tôi lấy dữ liệu từ máy chủ trong background thread và sau đó cập nhật giao diện người dùng trong main thread.
Suspending functions
Có một chức năng đặc biệt gọi là Suspending function trong Corlinines của Kotlin, chúng ta có thể khai báo hàm bằng từ khóa. Các chức năng treo có thể tạm dừng việc thực thi một coroutine, có nghĩa là nó sẽ đợi cho đến khi các chức năng đình chỉ hoạt động trở lại. Vì bài đăng này là dành cho khái niệm cơ bản của Coroutines, chúng tôi sẽ thảo luận chi tiết hơn về các chức năng treo trong bài khác.
Hãy để quay trở lại đoạn code ở trên, nó có thể được chia thành bốn phần:
CoroutineScope
Định nghĩa một phạm vi cho các coroutines mới. Mỗi trình xây dựng coroutine là một phần mở rộng trên CoroutineScope và kế thừa coroutineContext của nó để tự động truyền cả các yếu tố bối cảnh và hủy bỏ.
Tất cả các coroutine chạy bên trong một CoroutineScope và nó cần một CoroutineContext (tôi sẽ nói về nó sau) như một tham số. Có một số phạm vi chúng tôi có thể sử dụng:
- CoroutineScope
Tạo phạm vi với CoroutineContext tùy chỉnh. Ví dụ, để xác định luồng, công việc mẹ và xử lý ngoại lệ theo nhu cầu của chúng ta.
1 2 3 4 | CoroutineScope(Dispatchers.Main + job + exceptionHandler).launch { ... } |
- MainScope
Tạo phạm vi chính cho các thành phần UI. Nó đang chạy trên luồng chính với Trình giám sát (), có nghĩa là sự thất bại của một trong những công việc con của nó đã giành được ảnh hưởng đến những người khác.
- Toàn cầu
Đây là một phạm vi mà không ràng buộc với bất kỳ công việc nào. Nó được sử dụng để khởi chạy các coroutines cấp cao nhất đang hoạt động trên toàn bộ thời gian ứng dụng và không bị hủy sớm.
CoroutineContext
Coroutine luôn thực thi trong một số ngữ cảnh được biểu thị bằng một giá trị của loại CoroutineContext. CoroutineContext là một tập hợp các phần tử, để xác định chính sách luồng, xử lý ngoại lệ, kiểm soát thời gian tồn tại của coroutine, v.v. Chúng ta có thể sử dụng toán tử cộng để kết hợp các yếu tố của CoroutineContext.
Có ba bối cảnh Coroutine quan trọng nhất – Công văn, CoroutineExceptionHandler và Job.
- Dispatchers
Xác định chủ đề nào chạy coroutine. Một coroutine có thể chuyển đổi bộ điều phối bất cứ lúc nào với withContext ().
- Dispatchers.Default:
Sử dụng một shared background pool của thread. Theo mặc định, số lượng thread tối đa được sử dụng bởi Dispatchers này bằng với số lõi CPU, nhưng ít nhất là hai. - Dispatchers.IO:
Chia sẻ các chủ đề với Dispatchers.Default, nhưng số lượng các chủ đề bị giới hạn bởi kotlinx.coroutines.io. - Dispatchers.Main:
Tương đương với main thread của Android. - Dispatchers.Unconfined:
Một bộ coroutine dispatcher không giới hạn bất kỳ thread cụ thể. Coroutine thực thi trong luồng hiện tại trước và cho phép coroutine tiếp tục trong bất kỳ luồng nào được sử dụng bởi chức năng suspending function tương ứng.
1 2 3 4 5 6 7 8 9 10 11 12 13 | CoroutineScope(Dispatchers.Unconfined).launch { // Writes code here running on Main thread. delay(1_000) // Writes code here running on `kotlinx.coroutines.DefaultExecutor`. withContext(Dispatchers.IO) { ... } // Writes code running on I/O thread. withContext(Dispatchers.Main) { ... } // Writes code running on Main thread. } |
- CoroutineExceptionHandler
Xử lý ngoại lệ.
Thông thường, các ngoại lệ chưa được phát hiện chỉ có thể là kết quả của các coroutines được tạo bằng trình xây dựng khởi chạy. Một coroutine được tạo bằng async luôn nắm bắt tất cả các ngoại lệ của nó và thể hiện chúng trong đối tượng Trì hoãn kết quả.
Ví dụ 1: Không thể bắt IOException () với bên ngoài try-catch.
Chúng ta không thể bọc toàn bộ CoroutineScope bằng try-catch, ứng dụng sẽ vẫn bị sập.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | try { CoroutineScope(Dispatchers.Main).launch { doSomething() } } catch (e: IOException) { // Cannot catch IOException() here. Log.d("demo", "try-catch: $e") } private suspend fun doSomething() { delay(1_000) throw IOException() } |
Ví dụ 2: Bắt IOException () với CoroutineExceptionHandler.
Nếu ngoại lệ không phải là CancellingException (), ví dụ, IOException (), thì nó sẽ được truyền tới CoroutineExceptionHandler.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | // Handles coroutine exception here. val handler = CoroutineExceptionHandler { _, throwable -> Log.d("demo", "handler: $throwable") // Prints "handler: java.io.IOException" } CoroutineScope(Dispatchers.Main + handler).launch { doSomething() } private suspend fun doSomething() { delay(1_000) throw IOException() } |
Ví dụ 3: CancellingException () bị bỏ qua.
Nếu ngoại lệ là CancellingException thì nó sẽ bị bỏ qua (Bởi vì đó là cơ chế được cho là để hủy bỏ coroutine đang chạy, và ngoại lệ này won đã được truyền tới CoroutineExceptionHandler.)
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 | // Handles coroutine exception here. val handler = CoroutineExceptionHandler { _, throwable -> // Won't print the log because the exception is "CancellationException()". Log.d("demo", "handler: $throwable") } CoroutineScope(Dispatchers.Main + handler).launch { doSomething() } private suspend fun doSomething() { delay(1_000) throw CancellationException() } |
Ví dụ 4: Sử dụng invokeOnCompletion để lấy tất cả thông tin ngoại lệ.
CancellingException () sẽ không được truyền tới CoroutineExceptionHandler. Nếu chúng tôi muốn in một số thông tin sau khi ngoại lệ xảy ra, chúng tôi có thể sử dụng invokeOnCompletion để đạt được nó.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 | val job = CoroutineScope(Dispatchers.Main).launch { doSomething() } job.invokeOnCompletion { val error = it ?: <a class="__cf_email__" href="/cdn-cgi/l/email-protection" data-cfemail="3446514041465a745d5a425b5f517b5a775b59445851405d5b5a">[email protected]</a> // Prints "invokeOnCompletion: java.util.concurrent.CancellationException". Log.d("demo", "invokeOnCompletion: $error") } } private suspend fun doSomething() { delay(1_000) throw CancellationException() } |