Android ਵਿੱਚ threading ਅਤੇ concurrency ਕਿਵੇਂ ਕੰਮ ਕਰਦੀ ਹੈ?

Question

Accepted Answer

Android ਕੋਲ ਇੱਕ ਸਖਤ **threading model** ਹੈ ਜੋ **main (UI) thread** ਦੇ ਆਲੇ-ਦੁਆਲੇ ਕੇਂਦਰਿਤ ਹੈ — ਜੋ UI ਨੂੰ ਸੰਭਾਲਣਾ ਅਤੇ ਜਵਾਬਦੇਹ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ। Threading ਨੂੰ ਸਮਝਣਾ, ਕਿਉਂ ਕੰਮ ਨੂੰ main thread ਤੋਂ ਹਟਾਉਣਾ ਚਾਹੀਦਾ ਹੈ, ਅਤੇ ਟੂਲਸ (coroutines, ਅਤੇ ਇਤਿਹਾਸਕ ਰੂਪ ਵਿੱਚ threads/handlers) ਜਵਾਬਦੇਹ ਐਪਸ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ।

## Main thread ਨਿਯਮ

```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
```

## Main thread ਤੋਂ ਕੰਮ ਨੂੰ ਹਟਾਉਣਾ

```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)
```

## Concurrency ਟੂਲਸ ਅਤੇ ਵਿਚਾਰ

```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)
```

## ਇਹ ਕਿਉਂ ਮਹੱਤਵਪੂਰਨ ਹੈ

Android threading ਅਤੇ concurrency ਨੂੰ ਸਮਝਣਾ ਸੀਨਿਅਰ-ਲੈਵਲ ਦਾ ਮਹੱਤਵਪੂਰਨ ਜ੍ਞਾਨ ਹੈ ਕਿਉਂਕਿ **main-thread model Android ਲਈ ਮੂਲ ਹੈ**, ਅਤੇ threading ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਣਾ ਜਵਾਬਦੇਹ, ਸਹੀ ਐਪਸ ਲਈ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ, ਇਸ ਲਈ ਇਹ ਮੁੱਲਵਾਨ ਪਲੇਟਫਾਰਮ ਜ੍ਞਾਨ ਹੈ।

Android ਦਾ **ਸਿੰਗਲ main (UI) thread** — ਜੋ ਸਾਰੇ UI ਨੂੰ ਸੰਭਾਲਦਾ ਹੈ ਅਤੇ ਜਵਾਬਦੇਹ ਰਹਿਣਾ ਚਾਹੀਦਾ ਹੈ — ਦੋ ਬੁਨਿਆਦੀ ਨਿਯਮ ਲਾਗੂ ਕਰਦਾ ਹੈ: **main thread ਨੂੰ ਲੰਬੇ/ਬਲਾਕਿੰਗ ਕੰਮ ਨਾਲ ਬਲਾਕ ਨਾ ਕਰੋ** (ਨੈੱਟਵਰਕ, ਡਾਟਾਬੇਸ, ਭਾਰੀ ਗਣਨਾ), ਕਿਉਂਕਿ ਬਲਾਕਿੰਗ UI ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰਦਾ ਹੈ ਅਤੇ **ANR** ਗਲਤੀਆਂ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ (ਇੱਕ ਚੋਟੀ ਸਮੱਸਿਆ), ਅਤੇ **ਪਿਛੋਕੜ ਥ੍ਰੈਡ ਤੋਂ UI ਨੂੰ ਅਪਡੇਟ ਨਾ ਕਰੋ** (UI ਅਪਡੇਟਸ main thread ਦੇ ਮਾਪਦੰਡ ਜ਼ਰੂਰਤ)।

ਇਹ ਨਿਯਮਾਂ ਨੂੰ ਸਮਝਣਾ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ ਕਿਉਂਕਿ ਉਹਨਾਂ ਦੀ ਉਲੰਘਣਾ ਸਭ ਤੋਂ ਆਮ Android ਸਮੱਸਿਆਵਾਂ (ਫ੍ਰੀਜ਼ UI, ANRs, ਔਫ-ਥ੍ਰੈਡ UI ਅਪਡੇਟਸ ਤੋਂ ਕ੍ਰੈਸ਼ਜ਼) ਦਾ ਕਾਰਨ ਬਣਦੀ ਹੈ।

**ਕਿਵੇਂ ਕੰਮ ਨੂੰ main thread ਤੋਂ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਹਟਾਉਣਾ ਹੈ** ਨੂੰ ਸਮਝਣਾ — ਆਧੁਨਿਕ ਪਹੁੰਚ **dispatchers ਦੇ ਨਾਲ coroutines** ਦੀ (IO/ਭਾਰੀ ਕੰਮ ਨੂੰ background dispatchers ਜਿਵੇਂ Dispatchers.IO 'ਤੇ ਚਲਾਉਣਾ, ਫਿਰ lifecycle-aware scopes ਦੇ ਅੰਦਰ UI ਅਪਡੇਟਸ ਲਈ main thread 'ਤੇ ਵਾਪਸ ਜਾਣਾ) — ਜਵਾਬਦੇਹ ਐਪਸ ਲਈ ਜ਼ਰੂਰੀ ਵਿਹਾਰਕ ਹੁਨਰ ਹੈ, ਅਤੇ threading ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਸਿਫਾਰਸ਼ ਕੀਤਾ, ਸਾਫ ਤਰੀਕਾ ਪ੍ਰਤੀਨਿਧਿਤ ਕਰਦਾ ਹੈ।

**Concurrency ਟੂਲਸ** ਨੂੰ ਸਮਝਣਾ (coroutines ਆਧੁਨਿਕ ਮਿਆਰ ਦੇ ਰੂਪ ਵਿੱਚ; ਸਮਸਾਮ ਲਈ ਐਤਿਹਾਸਕ Thread/Handler/AsyncTask/RxJava) ਅਤੇ **concurrency ਖਤਰੇ** (ਰੇਸ ਕੰਡੀਸ਼ਨਸ, ਸਮਝਦਾਰੀ ਜ਼ਬਾਨ ਲਾ ਸਮਕਾਲੀਨ ਸਥਿਤੀ ਜਿਸ ਲਈ synchronization ਜ਼ਰੂਰੀ ਜ਼ਬਾਨ ਰਵੈਯਾ) ਸਹੀ concurrent ਕੋਡ ਲਈ ਜ਼ਰੂਰੀ ਡਿੱਪਰ ਸਮਝ ਪ੍ਰਤੀਬਿੰਬਿਤ ਕਰਦਾ ਹੈ, ਅਤੇ lifecycle scopes ਦੁਆਰਾ ਪਿਛੋਕੜ ਕੰਮ ਨੂੰ ਰੱਦ ਕਰਨ ਦੀ ਸਮਝ ਰਿਸਾਵਾਂ ਨੂੰ ਰੋਕਦਾ ਹੈ।

ਕਿਉਂਕਿ main-thread model Android ਲਈ ਬੁਨਿਆਦੀ ਹੈ (ਇਸ ਨੂੰ ਬਲਾਕ ਕਰਨਾ ਜ਼ਬਾਨ off-thread ਤੋਂ UI ਨੂੰ ਅਪਡੇਟ ਕਰਨਾ ਸਭ ਤੋਂ ਆਮ ਸਮੱਸਿਆਵਾਂ ਦਾ ਕਾਰਨ ਬਣਦਾ ਹੈ) ਅਤੇ coroutines ਦੁਆਰਾ threading ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਸੰਭਾਲਣਾ ਜਵਾਬਦੇਹ, ਸਹੀ ਐਪਸ ਲਈ ਜ਼ਰੂਰੀ ਹੈ, ਅਤੇ threading ਨਿਯਮਾਂ, main thread ਤੋਂ ਕੰਮ ਨੂੰ ਸਹੀ ਤਰੀਕੇ ਨਾਲ ਕਿਵੇਂ ਹਟਾਉਣਾ ਹੈ, ਅਤੇ concurrency ਖਤਰਿਆਂ ਨੂੰ ਸਮਝਣਾ ਜ਼ਰੂਰੀ ਪਲੇਟਫਾਰਮ ਜ੍ਞਾਨ ਹੈ, Android threading ਅਤੇ concurrency ਨੂੰ ਸਮਝਣਾ ਸੀਨਿਅਰ-ਲੈਵਲ ਦਾ ਮਹੱਤਵਪੂਰਨ ਜ੍ਞਾਨ ਹੈ — ਜਵਾਬਦੇਹ ਐਪਸ ਬਣਾਉਣ ਲਈ ਕੇਂਦਰੀ, ਬੁਨਿਆਦੀ Android ਰੋਕਾਂ ਨੂੰ ਸੰਬੋਧਿਤ ਕਰਦੇ ਹੋਏ, ਅਤੇ ਸੀਨਿਅਰ ਕਿਰਦਾਰਾਂ ਲਈ ਅਨੁਮਾਨਿਤ ਪਲੇਟਫਾਰਮ ਮਾਹਿਰੀ ਨੂੰ ਪ੍ਰਤੀਬਿੰਬਿਤ ਕਰਦੇ ਹੋਏ ਜੋ ਨਿਸ਼ਚਿਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਕਿ ਐਪਸ ਜਵਾਬਦੇਹ ਰਹਿਣ ਜਦੋਂ ਅਸਮਕਾਲੀਨ ਕੰਮ ਕਰ ਰਹੇ ਹਨ ਜੋ ਅਸਲ ਐਪਸ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।