Bagaimana threading dan concurrency berfungsi dalam Android?

Question

Accepted Answer

Android mempunyai **model threading** yang ketat berpusat pada **thread utama (UI)** — yang mesti mengendalikan UI dan kekal responsif. Memahami threading, mengapa kerja mesti dipindahkan dari thread utama, dan alatnya (coroutines, dan secara sejarah threads/handlers) adalah penting untuk aplikasi yang responsif.

## Peraturan thread utama

```text
Android has a single MAIN (UI) thread that:
  → handles ALL UI operations (drawing, events) — UI updates MUST happen on it
  → must stay RESPONSIVE — blocking it freezes the UI; >5s blocked = ANR (App Not Responding)
TWO key rules:
  1. DON'T do long/blocking work on the main thread (network, DB, heavy compute) → move it off
  2. DON'T update UI from a background thread → switch back to the main thread for UI
```

## Memindahkan kerja dari thread utama

```kotlin
// MODERN: coroutines with dispatchers (the recommended approach)
viewModelScope.launch {
  val data = withContext(Dispatchers.IO) {   // heavy/IO work on a background thread
    repository.fetchData()                    // network/DB off the main thread
  }
  updateUi(data)                              // back on the main thread → safe UI update
}
// Dispatchers: Main (UI), IO (network/disk), Default (CPU-intensive)
```

## Alat concurrency dan pertimbangan

```text
→ COROUTINES (modern, recommended) → structured, lightweight, with dispatchers and scopes
→ Historically: Thread, Handler/Looper, AsyncTask (deprecated), executors, RxJava
→ Concurrency hazards: race conditions, shared mutable state → synchronize/avoid shared
  mutable state; use thread-safe patterns
→ Lifecycle: cancel background work when no longer needed (lifecycle-scoped coroutines)
```

## Mengapa ia penting

Memahami threading dan concurrency Android adalah pengetahuan peringkat senior yang penting kerana **model thread utama adalah asas kepada Android**, dan mengendalikan threading dengan betul adalah penting untuk aplikasi yang responsif dan betul, jadi ia merupakan pengetahuan platform yang berharga.

**Thread utama (UI) tunggal** Android — yang mengendalikan semua UI dan mesti kekal responsif — mengenakan dua peraturan asas: **jangan sekat thread utama** dengan kerja panjang/menyekat (rangkaian, pangkalan data, pengiraan berat), kerana menyekat membekukan UI dan menyebabkan ralat **ANR** (masalah teratas), dan **jangan kemas kini UI dari thread latar belakang** (kemas kini UI mesti berlaku pada thread utama).

Memahami peraturan ini adalah penting kerana melanggarnya menyebabkan masalah Android yang paling biasa (UI beku, ANR, kerosakan daripada kemas kini UI di luar thread).

Memahami **cara memindahkan kerja dari thread utama** dengan betul — pendekatan moden menggunakan **coroutines dengan dispatchers** (menjalankan kerja IO/berat pada dispatcher latar belakang seperti Dispatchers.IO, kemudian beralih semula ke thread utama untuk kemas kini UI, kesemuanya dalam skop sedar kitar hayat) — ialah kemahiran praktikal penting untuk aplikasi yang responsif, dan mewakili cara yang disyorkan dan bersih untuk mengendalikan threading.

Memahami **alat concurrency** (coroutines sebagai standard moden; Thread/Handler/AsyncTask/RxJava sejarah untuk konteks) dan **bahaya concurrency** (race conditions, shared mutable state yang memerlukan penyegerakan atau pengelakan) mencerminkan pemahaman lebih mendalam yang diperlukan untuk kod konkuren yang betul, dan mengetahui untuk membatalkan kerja latar belakang melalui lifecycle scopes mencegah kebocoran.

Memandangkan model thread utama adalah asas kepada Android (dengan menyekatnya atau mengemas kini UI di luar thread menyebabkan masalah yang paling biasa) dan mengendalikan threading dengan betul melalui coroutines adalah penting untuk aplikasi yang responsif dan betul, dan memandangkan memahami peraturan threading, cara memindahkan kerja dari thread utama dengan betul, dan bahaya concurrency adalah pengetahuan platform yang perlu, memahami threading dan concurrency Android adalah pengetahuan peringkat senior yang penting — teras kepada membina aplikasi yang responsif, menangani kekangan asas Android, dan mencerminkan kepakaran platform yang dijangka untuk peranan senior yang mesti memastikan aplikasi kekal responsif sambil melakukan kerja asinkron yang diperlukan oleh aplikasi sebenar.