Threading và concurrency hoạt động như thế nào trong Android?

Question

Accepted Answer

Android có một **mô hình threading** nghiêm ngặt xoay quanh **main (UI) thread** — vốn phải xử lý UI và luôn phản hồi. Hiểu threading, tại sao công việc phải chuyển ra khỏi main thread, và các công cụ (coroutine, và trong lịch sử là thread/handler) là quan trọng cho ứng dụng phản hồi.

## Quy tắc main thread

```text
Android có một MAIN (UI) thread duy nhất:
  → xử lý TẤT CẢ thao tác UI (vẽ, sự kiện) — cập nhật UI PHẢI xảy ra trên nó
  → phải luôn PHẢN HỒI — chặn nó làm đơ UI; chặn >5s = ANR (App Not Responding)
HAI quy tắc then chốt:
  1. ĐỪNG làm công việc dài/chặn trên main thread (mạng, DB, tính toán nặng) → chuyển ra khỏi nó
  2. ĐỪNG cập nhật UI từ một background thread → chuyển lại main thread cho UI
```

## Chuyển công việc ra khỏi main thread

```kotlin
// HIỆN ĐẠI: coroutine với dispatcher (cách tiếp cận được khuyến nghị)
viewModelScope.launch {
  val data = withContext(Dispatchers.IO) {   // công việc nặng/IO trên một background thread
    repository.fetchData()                    // mạng/DB ngoài main thread
  }
  updateUi(data)                              // trở lại main thread → cập nhật UI an toàn
}
// Dispatcher: Main (UI), IO (mạng/đĩa), Default (CPU nặng)
```

## Các công cụ và cân nhắc concurrency

```text
→ COROUTINE (hiện đại, được khuyến nghị) → có cấu trúc, nhẹ, với dispatcher và scope
→ Trong lịch sử: Thread, Handler/Looper, AsyncTask (deprecated), executor, RxJava
→ Hiểm họa concurrency: race condition, shared mutable state → đồng bộ hóa/tránh shared
  mutable state; dùng các mẫu thread-safe
→ Lifecycle: hủy công việc nền khi không còn cần (coroutine có scope lifecycle)
```

## Tại sao điều này quan trọng

Hiểu threading và concurrency Android là kiến thức cấp senior quan trọng vì **mô hình main-thread là nền tảng của Android**, và xử lý threading đúng cách là thiết yếu cho ứng dụng phản hồi, đúng đắn, nên đây là kiến thức nền tảng giá trị. **Main (UI) thread duy nhất** của Android — vốn xử lý tất cả UI và phải luôn phản hồi — áp đặt hai quy tắc cơ bản: **đừng chặn main thread** với công việc dài/chặn (mạng, cơ sở dữ liệu, tính toán nặng), vì chặn làm đơ UI và gây lỗi **ANR** (một vấn đề hàng đầu), và **đừng cập nhật UI từ một background thread** (cập nhật UI phải xảy ra trên main thread).

Hiểu các quy tắc này là thiết yếu vì vi phạm chúng gây ra các vấn đề Android phổ biến nhất (UI đơ, ANR, crash từ cập nhật UI ngoài thread).

Hiểu **cách chuyển công việc ra khỏi main thread** đúng cách — cách tiếp cận hiện đại dùng **coroutine với dispatcher** (chạy công việc IO/nặng trên các background dispatcher như Dispatchers.IO, rồi chuyển lại main thread cho cập nhật UI, tất cả trong các scope nhận biết lifecycle) — là kỹ năng thực tiễn thiết yếu cho ứng dụng phản hồi, và đại diện cho cách gọn gàng, được khuyến nghị để xử lý threading.

Hiểu các **công cụ concurrency** (coroutine là tiêu chuẩn hiện đại; Thread/Handler/AsyncTask/RxJava lịch sử cho bối cảnh) và **hiểm họa concurrency** (race condition, shared mutable state yêu cầu đồng bộ hóa hoặc tránh) phản ánh sự hiểu biết sâu hơn cần cho code concurrent đúng đắn, và biết hủy công việc nền qua các lifecycle scope ngăn rò rỉ.

Vì mô hình main-thread là nền tảng của Android (với việc chặn nó hoặc cập nhật UI ngoài thread gây ra các vấn đề phổ biến nhất) và xử lý threading đúng cách qua coroutine là thiết yếu cho ứng dụng phản hồi, đúng đắn, và vì hiểu các quy tắc threading, cách chuyển công việc ra khỏi main thread đúng cách, và các hiểm họa concurrency là kiến thức nền tảng cần thiết, nên hiểu threading và concurrency Android là kiến thức cấp senior quan trọng — trung tâm để xây dựng ứng dụng phản hồi, giải quyết các ràng buộc Android cơ bản, và phản ánh chuyên môn nền tảng được kỳ vọng cho vai trò senior phải đảm bảo ứng dụng luôn phản hồi trong khi làm công việc bất đồng bộ mà ứng dụng thực yêu cầu.