Android Developer Roadmap: Lập trình Bất đồng bộ trong Android – Coroutines, Threads, và RxJava

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ớ.

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.
  • AsyncTask deprecated từ API 30. Thread trần, Handler, Looper chỉ 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, repeatOnLifecycle và 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 Exception trầ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 launch tạ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ó runBlocking ngoà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ên Dispatchers.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 Exception trần; CancellationException luôn được ném lại.
  • Flow được collect trong repeatOnLifecycle hoặc collectAsStateWithLifecycle(); RxJava có dispose() ở onDestroyView.
  • Test async viết bằng runTest, không Thread.sleep trong test.

Đọc tiếp