Niềm tin cần bỏ: “lập trình bất đồng bộ trong Android nghĩa là tạo Thread, hoặc dùng RxJava nếu muốn nghiêm túc”. Vào 2026 cả hai đều sai. Coroutine là mặc định của Kotlin trên Android, Jetpack đã chuyển sang hàm suspend và Flow, còn RxJava chỉ còn trong codebase cũ. Dưới đây là mô hình đúng để viết async, code chạy được, cách huỷ và bắt lỗi, cùng bảy bẫy làm app treo hoặc rò rỉ bộ nhớ.
Mục lục
Cập nhật 2026: coroutine là mặc định, RxJava là di sản
- Kotlin 2.4.21 stable (2026-10-08);
kotlinx.coroutinesđang ở dòng 1.10+, API cốt lõi đã ổn định nên bài này không pin số version. AsyncTaskdeprecated từ API 30. Thread trần,Handler,Looperchỉ còn cho tác vụ cấp thấp, không phải lựa chọn mặc định.- Lifecycle 2.11.0 cung cấp
viewModelScope,lifecycleScope,repeatOnLifecyclevàcollectAsStateWithLifecycle. - RxJava không biến mất, nhưng code mới không nên bắt đầu bằng nó. Bạn vẫn phải đọc, sửa và di trú được code cũ.
Lập trình bất đồng bộ trong Android: mô hình nên nắm
Main thread phục vụ UI. Một tác vụ chặn nó quá 5 giây sinh ANR; chặn nó dù chỉ 16 ms làm rơi frame. Mục tiêu của async không phải “chạy song song” mà là không giữ main thread trong lúc chờ: chờ mạng, chờ đĩa, chờ database đều phải nhường luồng.
Thread là tài nguyên của hệ điều hành: mỗi thread có stack riêng, số thread đồng thời bị giới hạn bởi bộ nhớ. Coroutine là tác vụ do runtime Kotlin lập lịch trên một pool thread; vài nghìn coroutine chia sẻ vài chục thread. Khi coroutine “tạm dừng”, nó lưu continuation rồi trả thread về pool — thread không bị block, nên vẫn phục vụ coroutine khác.
| Tiêu chí | Thread | Coroutine |
|---|---|---|
| Đơn vị lập lịch | Hệ điều hành | Runtime Kotlin (dispatcher) |
| Chi phí | Stack riêng, tạo/huỷ đắt | Object nhẹ, tạo/huỷ rẻ |
| Huỷ | interrupt(), phải tự kiểm tra |
Job.cancel(), lan xuống con |
| Bắt lỗi | Uncaught handler toàn cục | try/catch, lan lên cha |
Nhưng coroutine không tự chạy song song: trong cùng một scope, chúng chạy tuần tự tới điểm suspend đầu tiên. Song song là chuyện của async, không phải của launch.
suspend: hàm không chặn luồng
suspend không phải “chạy nền”. Nó chỉ có nghĩa: hàm này có thể tạm dừng và tiếp tục sau, nên chỉ gọi được từ coroutine hoặc từ hàm suspend khác. Hàm suspend do thư viện cung cấp (delay, Retrofit, Room, DataStore 1.3.0) đều huỷ được. Hàm suspend bạn tự viết mà bên trong gọi Thread.sleep hay OkHttp execute() thì vẫn chặn thread — đó là lý do có withContext.
Scope, launch, async và await
CoroutineScope giữ Job gốc và quyết định coroutine sống bao lâu. launch trả về Job cho tác vụ không cần kết quả; async trả về Deferred<T>, lấy kết quả bằng await(). Cả hai đều là con của scope, nên huỷ scope là huỷ chúng.
// File: data/DashboardRepository.kt
import kotlinx.coroutines.*
class DashboardRepository(private val api: DashboardApi) {
suspend fun load(userId: String): Dashboard = coroutineScope {
val profile = async { api.profile(userId) } // bắt đầu ngay
val orders = async { api.orders(userId) }
val badges = async { api.badges(userId) }
Dashboard(
profile = profile.await(), // chỉ chờ ở đây
orders = orders.await(),
badges = badges.await(),
)
}
}
coroutineScope chờ mọi con xong; một con lỗi thì huỷ các con còn lại. Ba request chạy song song nên tổng thời gian xấp xỉ request chậm nhất, thay vì tổng ba request.
Dispatchers: chọn đúng luồng
| Dispatcher | Dùng cho | Lưu ý |
|---|---|---|
Main |
UI, state của ViewModel | Một thread; blocking ở đây là ANR |
IO |
Đọc/ghi file, JDBC, thư viện blocking | Pool co giãn, mặc định tối đa 64 thread |
Default |
Parse, tính toán, sort dữ liệu lớn | Giới hạn theo số core (tối thiểu 2) |
Đừng bọc Dispatchers.IO quanh Retrofit hay Room dạng suspend: chúng đã tự chuyển sang executor riêng. Chỉ withContext(Dispatchers.IO) khi gọi API blocking thật như File.readText() hay SDK cũ.
// File: data/ReportRepository.kt
suspend fun exportReport(rows: List<Row>, file: File): File {
val csv = withContext(Dispatchers.Default) { renderCsv(rows) } // CPU-bound
withContext(Dispatchers.IO) { file.writeText(csv) } // blocking IO
return file
}
withContext không tạo scope mới: cùng coroutine, dispatcher khác, vẫn huỷ được; xong block thì quay về dispatcher cũ. Đó là cách chuẩn để “xuống IO rồi lên Main”.
Structured concurrency và huỷ
Ba quy tắc của structured concurrency: cha chờ con, lỗi con huỷ anh em và lan lên cha, huỷ cha lan xuống con. Nhờ vậy không có coroutine “mồ côi” chạy sau khi màn hình đã chết — miễn là bạn không tự tạo scope sống lâu hơn UI.
Huỷ là hợp tác (cooperative). cancel() chỉ đánh dấu Job; coroutine dừng ở điểm suspend kế tiếp. Vòng lặp thuần tính toán không có suspend sẽ không dừng, nên phải gọi ensureActive() hoặc kiểm tra isActive trong vòng lặp dài.
// File: ui/upload/UploadViewModel.kt
private var job: Job? = null
fun start(uri: Uri) {
job?.cancel() // huỷ lần trước, không cho hai upload đua
job = viewModelScope.launch {
try {
val total = withContext(Dispatchers.IO) { fileSize(uri) }
for (part in 0 until total step CHUNK) {
ensureActive() // ném CancellationException nếu đã huỷ
api.uploadPart(uri, part) // suspend, huỷ theo coroutine
_progress.value = part / CHUNK + 1
}
_done.value = true
} catch (e: CancellationException) {
throw e // huỷ không phải lỗi: phải ném lại
} catch (e: IOException) {
_error.value = "Upload thất bại: ${e.message}"
}
}
}
Khi người dùng rời màn hình, viewModelScope chỉ bị huỷ lúc ViewModel bị clear — với Navigation là khi back stack entry bị destroy, không phải lúc app xuống background. Nếu công việc phải dừng ngay khi UI không còn hiển thị, dùng lifecycleScope hoặc repeatOnLifecycle; nếu phải chạy tiếp qua cả việc rời màn hình, giữ nó trong ViewModel hoặc WorkManager 2.12.0.
Xử lý ngoại lệ: ba cấp
- try/catch trong thân coroutine cho lỗi bạn dự đoán được; đừng catch
Exceptiontrần vì sẽ nuốt cảCancellationException. - coroutineScope lan lỗi và huỷ anh em — mặc định nên dùng. supervisorScope cô lập lỗi: con này chết không kéo con khác.
- CoroutineExceptionHandler chỉ có tác dụng với coroutine gốc do
launchtạo và không có ai bắt lỗi phía trên. Nó không bắt lỗi từasync— lỗi đó xuất hiện ởawait().
// File: data/SyncRepository.kt
suspend fun syncAll(accounts: List<Account>): List<SyncResult> = supervisorScope {
accounts.map { account ->
async {
try {
sync(account)
SyncResult.Ok(account.id)
} catch (e: IOException) {
SyncResult.Failed(account.id, e.message) // một tài khoản lỗi, còn lại vẫn chạy
}
}
}.awaitAll()
}
// Chỉ cho coroutine gốc: lỗi không làm app crash im lặng
val handler = CoroutineExceptionHandler { _, e -> log("Coroutine lỗi: ${e.message}") }
val scope = CoroutineScope(SupervisorJob() + Dispatchers.Main + handler)
Nếu bạn đang bắt lỗi bằng catch (e: Exception) trong một coroutine, hãy thêm nhánh catch (e: CancellationException) { throw e } trước. Nuốt nó khiến Job cha tưởng con đã xong bình thường và không bao giờ kết thúc đúng cách.
viewModelScope, lifecycleScope và repeatOnLifecycle
| Scope | Sống đến khi | Dùng cho |
|---|---|---|
viewModelScope |
ViewModel bị clear | Việc thuộc về state màn hình, sống qua xoay màn hình |
lifecycleScope |
Lifecycle destroy | Việc gắn với UI, animation, dialog |
repeatOnLifecycle |
Xuống dưới STARTED | Collect Flow, đăng ký listener |
// File: ui/feed/FeedFragment.kt
override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
viewLifecycleOwner.lifecycleScope.launch {
viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
viewModel.feed.collectLatest { items -> render(items) }
}
}
}
repeatOnLifecycle huỷ block khi xuống dưới STARTED và chạy lại khi lên — collector không chạy trong background, không tốn pin, không giữ Room observer. Đừng dùng launchWhenStarted: nó đã deprecated vì chỉ trì hoãn chứ không huỷ collector. Với Compose, dùng collectAsStateWithLifecycle() từ lifecycle-runtime-compose thay vì tự collect trong composition.
Flow: luồng dữ liệu lạnh
flow {} là cold: không collector thì không chạy, mỗi collector chạy lại từ đầu — nên repository trả Flow, ViewModel dùng stateIn để thành state. Operator (map, filter, debounce, combine, flatMapLatest) chạy trên dispatcher của collector trừ khi bạn đặt flowOn.
| Tiêu chí | Channel | Flow |
|---|---|---|
| Bản chất | Hàng đợi, giao tiếp giữa coroutine | Khai báo pipeline dữ liệu |
| Số consumer | Mỗi phần tử cho đúng một consumer | Mỗi collector nhận toàn bộ luồng |
| Dùng cho | Hàng đợi sự kiện nội bộ, callbackFlow |
Nguồn Room, DataStore, search, UI state |
Quy tắc chọn: mô tả dữ liệu chảy qua đâu thì dùng Flow; mô tả một việc cần làm một lần giữa hai coroutine thì dùng Channel. Đừng dùng Channel làm state UI, và đừng quên close() trong callbackFlow — channel không đóng sẽ treo collector mãi.
runBlocking chỉ trong test
runBlocking chặn thread gọi nó cho đến khi xong. Trên main thread, nó là ANR chắc chắn; trong code production, nó là dấu hiệu ai đó chưa hiểu async. Nó chỉ hợp lệ ở entry point của CLI, và trong test thì nên dùng runTest: test chạy trên virtual time nên delay không tốn thời gian thật.
// File: test/DashboardRepositoryTest.kt
@Test
fun `ba request chay song song`() = runTest {
val api = FakeApi(latencyMs = 1_000) // bên trong fake có delay(1_000)
val dashboard = DashboardRepository(api).load("u1")
assertEquals(3, dashboard.sections.size)
// runTest bỏ qua thời gian ảo: ba delay(1_000) tốn gần 0 ms thật
}
Với ViewModel dùng viewModelScope, đặt Main dispatcher bằng rule test để không phụ thuộc Android; và dùng advanceUntilIdle() khi cần chạy hết coroutine treo.
RxJava: ánh xạ sang coroutine
RxJava 3 vẫn tốt cho luồng sự kiện phức tạp, nhưng với app Kotlin mới nó là chi phí: thêm mental model, thêm Disposable, không tích hợp viewModelScope. Đọc code cũ thì dịch sang coroutine trước khi sửa.
| RxJava 3 | Coroutine / Flow |
|---|---|
Single<T> |
Hàm suspend trả T, hoặc async + await() |
Observable / Flowable |
Flow<T>, dựng bằng flow {} |
subscribeOn(Schedulers.io()) |
withContext(Dispatchers.IO) hoặc flowOn(Dispatchers.IO) |
observeOn(AndroidSchedulers.mainThread()) |
Collect trên Dispatchers.Main |
CompositeDisposable + dispose() |
Scope + Job.cancel() |
// File: ui/legacy/ProfileFragment.kt — RxJava 3, chỉ để bảo trì code cũ
private val bag = CompositeDisposable()
fun load(userId: String) {
bag.add(
api.profile(userId) // Single<Profile>
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(
{ profile -> textView.text = profile.name },
{ error -> toast("Lỗi: ${error.message}") },
),
)
}
override fun onDestroyView() {
bag.clear() // quên dòng này là leak Fragment
super.onDestroyView()
}
Single của Retrofit cần artifact adapter-rxjava3; AndroidSchedulers.mainThread() cần io.reactivex.rxjava3:rxandroid. Khi cần gọi code legacy từ coroutine mà không rewrite, viết một cầu suspend nhỏ — huỷ coroutine sẽ dispose() luôn request:
// File: data/RxBridge.kt
import io.reactivex.rxjava3.core.Single
import io.reactivex.rxjava3.functions.Consumer
import kotlinx.coroutines.suspendCancellableCoroutine
import kotlin.coroutines.resume
import kotlin.coroutines.resumeWithException
suspend fun <T : Any> Single<T>.awaitValue(): T = suspendCancellableCoroutine { cont ->
val disposable = subscribe(
Consumer<T> { value -> cont.resume(value) },
Consumer<Throwable> { error -> cont.resumeWithException(error) },
)
cont.invokeOnCancellation { disposable.dispose() }
}
Thư viện chính thức kotlinx-coroutines-rx3 có sẵn adapter tương đương (asFlow(), await()) — cài nó trước khi tự viết bridge cho cả codebase. Đừng trộn hai mô hình trong cùng một luồng dữ liệu: hoặc cả pipeline là Flow, hoặc cả pipeline là Rx, chỉ đổi ở biên.
Bảy bẫy thường gặp
| Bẫy | Cách sửa |
|---|---|
GlobalScope.launch cho mọi việc |
Không ai huỷ được, rò rỉ và chạy sau khi màn hình chết; dùng viewModelScope/lifecycleScope |
catch (e: Exception) nuốt CancellationException |
Thêm catch (e: CancellationException) { throw e } trước nhánh kia |
Blocking trong Dispatchers.Main: Thread.sleep, runBlocking, OkHttp execute() |
Chuyển sang Dispatchers.IO hoặc dùng API suspend |
async không await |
Lỗi mất cho đến khi GC huỷ Deferred và app crash khó lần; luôn await()/awaitAll() hoặc dùng launch |
| Tạo coroutine không giới hạn trong vòng lặp | Nghẽn dispatcher; giới hạn bằng Semaphore(4) hoặc limitedParallelism |
| Scope tự tạo trong singleton, giữ Activity | Scope sống mãi và giữ reference; huỷ trong onCleared hoặc dùng scope của lifecycle |
Quên dispose()/bag.clear() khi dùng RxJava |
Subscription giữ Fragment/Activity; clear trong onDestroyView |
Khi nào dùng cái nào
| Tình huống | Chọn | Ghi chú |
|---|---|---|
| Gọi API trong ViewModel | viewModelScope.launch + repository suspend |
Retrofit/Room tự lo IO |
| Nhiều request độc lập | coroutineScope + async/awaitAll |
Song song, lỗi huỷ anh em |
| Stream dữ liệu lên UI | Flow + stateIn |
Collect bằng repeatOnLifecycle hoặc Compose lifecycle-aware |
| Việc phải dừng khi rời foreground | lifecycleScope / repeatOnLifecycle |
viewModelScope sống lâu hơn màn hình |
| CPU nặng | Dispatchers.Default |
Đừng đẩy sang IO để “an toàn” |
| Việc phải sống qua process death | WorkManager 2.12.0 | Không phải coroutine scope |
| Codebase đang dùng RxJava 3 | Giữ, thêm bridge ở biên | Rewrite hàng loạt không đáng |
Hướng 2027
Kotlin 2.5.0 dự kiến ra tháng 12/2026 nhưng không đổi mô hình coroutine. Phần đang dịch chuyển là tầng thư viện — Compose-first kéo state về StateFlow, còn KMP đẩy code async dùng chung sang module shared. RxJava sẽ co lại thành di sản bảo trì, không biến mất trong một sớm một chiều.
Checklist
- Không có
GlobalScope, không córunBlockingngoài test; mọi coroutine thuộc một scope có lifecycle. - Việc blocking chạy trên
Dispatchers.IO; tính toán nặng trênDispatchers.Default; Main chỉ chạm UI. - Mọi
asyncđều cóawait(), mọi vòng lặp dài cóensureActive(). - Không catch
Exceptiontrần;CancellationExceptionluôn được ném lại. - Flow được collect trong
repeatOnLifecyclehoặccollectAsStateWithLifecycle(); RxJava códispose()ởonDestroyView. - Test async viết bằng
runTest, khôngThread.sleeptrong test.



