Bagaimana cara kerja threading dan concurrency di Android?

Question

Accepted Answer

Android memiliki **model threading** yang ketat berpusat pada **thread utama (UI)** — yang harus menangani UI dan tetap responsif. Memahami threading, mengapa pekerjaan harus dipindahkan dari thread utama, dan alat-alat (coroutines, dan secara historis threads/handlers) penting untuk aplikasi yang responsif.

## Aturan 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 pekerjaan 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 ini penting

Memahami threading dan concurrency Android adalah pengetahuan tingkat senior yang penting karena **model thread utama adalah fundamental untuk Android**, dan menangani threading dengan benar sangat penting untuk aplikasi yang responsif dan benar, sehingga merupakan pengetahuan platform yang berharga.

**Thread utama (UI) tunggal** Android — yang menangani semua UI dan harus tetap responsif — memberlakukan dua aturan fundamental: **jangan blokir thread utama** dengan pekerjaan yang lama/blocking (network, database, komputasi berat), karena memblokir akan membekukan UI dan menyebabkan error **ANR** (masalah teratas), dan **jangan perbarui UI dari thread background** (pembaruan UI harus terjadi di thread utama).

Memahami aturan-aturan ini sangat penting karena melanggarnya menyebabkan masalah Android paling umum (UI yang membeku, ANR, crash dari pembaruan UI di luar thread).

Memahami **cara memindahkan pekerjaan dari thread utama** dengan benar — pendekatan modern menggunakan **coroutines dengan dispatchers** (menjalankan pekerjaan IO/berat pada dispatchers background seperti Dispatchers.IO, kemudian beralih kembali ke thread utama untuk pembaruan UI, semuanya dalam scope yang lifecycle-aware) — adalah keterampilan praktis penting untuk aplikasi yang responsif, dan merepresentasikan cara yang direkomendasikan dan bersih untuk menangani threading.

Memahami **alat concurrency** (coroutines sebagai standar modern; Thread/Handler/AsyncTask/RxJava historis untuk konteks) dan **bahaya concurrency** (race conditions, state mutable yang dibagikan memerlukan synchronization atau penghindaran) mencerminkan pemahaman lebih dalam yang diperlukan untuk kode concurrent yang benar, dan mengetahui cara membatalkan pekerjaan background melalui lifecycle scopes mencegah kebocoran.

Karena model thread utama adalah fundamental untuk Android (memblokirnya atau memperbarui UI di luar thread menyebabkan masalah paling umum) dan menangani threading dengan benar melalui coroutines sangat penting untuk aplikasi yang responsif dan benar, dan karena memahami aturan threading, cara memindahkan pekerjaan dari thread utama dengan benar, dan bahaya concurrency adalah pengetahuan platform yang diperlukan, memahami threading dan concurrency Android adalah pengetahuan tingkat senior yang penting — central untuk membangun aplikasi responsif, mengatasi batasan fundamental Android, dan mencerminkan keahlian platform yang diharapkan untuk peran senior yang harus memastikan aplikasi tetap responsif sambil melakukan pekerjaan asynchronous yang diperlukan aplikasi nyata.