Android இல் threading மற்றும் concurrency எவ்வாறு செயல்படுகிறது?

Question

Accepted Answer

Android ஆனது **main (UI) thread** மீதான엄격한**threading model** கொண்டுள்ளது — இது UI ஐ கையாள வேண்டும் மற்றும் responsive ஆக இருக்க வேண்டும். Threading ஐ புரிந்துகொள்ளுதல், main thread இலிருந்து work ஏன் நகர்த்த வேண்டும் என்பதைப் புரிந்துகொள்ளுதல், மற்றும் tools (coroutines, மற்றும் வரலாற்று ரீதியாக threads/handlers) ஆகியவை responsive apps க்கு முக்கியமாகும்.

## main thread rule

```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 இலிருந்து work நகர்த்துதல்

```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 tools மற்றும் பரிசீலனைகள்

```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 ஐ புரிந்துகொள்ளுதல் முக்கியமான senior-level அறிவு ஆகும், ஏனெனில் **main-thread model Android க்கு அடிப்படையாகும்**, மற்றும் threading ஐ சரியாக கையாளுதல் responsive, correct apps க்கு அத்யாவசியமாகும், எனவே இது மূল்யமான platform அறிவு.

Android இன் **single main (UI) thread** — இது அனைத்து UI ஐ கையாளுகிறது மற்றும் responsive ஆக இருக்க வேண்டும் — இரண்டு அடிப்படை விதிகளை விதிக்கிறது: **main thread ஐ block செய்யாதீர்கள்** long/blocking work (network, database, heavy computation) உடன், ஏனெனில் blocking UI ஐ freeze செய்கிறது மற்றும் **ANR** பிழைகளை ஏற்படுத்துகிறது (ஒரு முக்கிய பிரச்சனை), மற்றும் **background thread இலிருந்து UI ஐ update செய்யாதீர்கள்** (UI updates main thread இல் நடக்க வேண்டும்).

இந்த விதிகளைப் புரிந்துகொள்ளுதல் அத்யாவசியமாகும், ஏனெனில் இவற்றை மீறுவது மிகவும் பொதுவான Android பிரச்சனைகளை ஏற்படுத்துகிறது (frozen UIs, ANRs, off-thread UI updates இலிருந்து crashes).

சரியாக main thread இலிருந்து work நகர்த்துவது எப்படி என்பதைப் புரிந்துகொள்ளுதல் — **coroutines with dispatchers** ஐ பயன்படுத்தும் நவீன அணுகுமுறை (IO/heavy work ஐ background dispatchers இல் இயக்குதல் like Dispatchers.IO, பின்னர் UI updates க்கு main thread க்கு திரும்புதல், அனைத்தும் lifecycle-aware scopes க்குள்) — responsive apps க்கு அத்யாவசிய நடைமுறை திறமை ஆகும், மற்றும் threading ஐ கையாளுவதற்கான பரிந்துரைக்கப்பட்ட, clean வழியைப் பிரதிநிதித்துவம் செய்கிறது.

**Concurrency tools** ஐ புரிந்துகொள்ளுதல் (coroutines நவீன standard ஆக; historical Thread/Handler/AsyncTask/RxJava context க்கு) மற்றும் **concurrency hazards** (race conditions, shared mutable state synchronization அல்லது avoidance தேவைப்படுகிறது) ஆகியவை correct concurrent code க்கு தேவையான ஆழமான புரிதலைப் பிரதிநிதித்துவம் செய்கிறது, மற்றும் lifecycle scopes மூலம் background work ஐ cancel செய்வதை அறிவது leaks ஐ தடுக்கிறது.

main-thread model Android க்கு அடிப்படையாக இருப்பதால் (blocking அல்லது off-thread இல் UI update செய்வது மிகவும் பொதுவான பிரச்சனைகளை ஏற்படுத்துகிறது) மற்றும் threading ஐ coroutines மூலம் சரியாக கையாளுதல் responsive, correct apps க்கு அத்யாவசியமாக இருப்பதால், மற்றும் threading rules, main thread இலிருந்து work சரியாக நகர்த்துவது, மற்றும் concurrency hazards ஆகியவற்றைப் புரிந்துகொள்ளுதல் அத்யாவசிய platform அறிவாக இருப்பதால், Android threading மற்றும் concurrency ஐ புரிந்துகொள்ளுதல் முக்கியமான senior-level அறிவு — responsive apps கட்ட central, fundamental Android constraints ஐ உரிய கவனத்தளிக்க, மற்றும் senior roles க்கு expected platform expertise ஐ பிரதிநிதித்துவம் செய்கிறது, அவர்கள் apps responsive ஆக இருக்கும் போது asynchronous work ஐ பொறுத்துக்கொள்ள வேண்டிய real apps தேவைப்படுகிறது.