Jak funguje threading a concurrency v Androidu?

Question

Accepted Answer

Android má přísný **threading model** orientovaný na **main (UI) thread** — který musí zpracovávat UI a zůstat responsivní. Pochopení threadingu, proč se práce musí přesunout mimo main thread a dostupné nástroje (coroutines a historicky threads/handlers) jsou důležité pro responsivní aplikace.

## Pravidlo main threadu

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

## Přesun práce mimo 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)
```

## Nástroje concurrency a důležité aspekty

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

## Proč je to důležité

Pochopení Android threadingu a concurrency je důležité znalosti na senior úrovni, protože **main-thread model je základní pro Android**, a správné zpracování threadingu je zásadní pro responsivní a korektní aplikace, takže jde o cenné znalosti platformy.

Android má **jeden main (UI) thread** — který zpracovává veškeré UI a musí zůstat responsivní — což ukládá dvě základní pravidla: **neblokuj main thread** dlouhou/blokující prací (síť, databáze, těžké výpočty), protože blokování zamrzne UI a způsobí **ANR** chyby (jeden z hlavních problémů), a **neaktualizuj UI z background threadu** (UI aktualizace musí probíhat na main threadu).

Pochopení těchto pravidel je zásadní, protože jejich porušení způsobuje nejčastější Android problémy (zamrzlé UI, ANRy, chyby z UI aktualizací mimo thread).

Pochopení **jak správně přesunout práci mimo main thread** — moderní přístup pomocí **coroutines s dispatchery** (spuštění IO/těžké práce na background dispatcherech jako Dispatchers.IO, pak přepnutí zpět na main thread pro UI aktualizace, vše v lifecycle-aware scope) — je zásadní praktická dovednost pro responsivní aplikace a představuje doporučený, čistý způsob zpracování threadingu.

Pochopení **nástrojů concurrency** (coroutines jako moderní standard; historicky Thread/Handler/AsyncTask/RxJava pro kontext) a **nebezpečí concurrency** (race conditions, sdílený mutable stav vyžadující synchronizaci nebo vyhnutí se mu) odráží hlubší pochopení potřebné pro korektní concurrent kód, a vědomí zrušit background práci přes lifecycle scopes brání úniku zdrojů.

Protože main-thread model je základní pro Android (blokování nebo aktualizace UI mimo thread způsobují nejčastější problémy) a správné zpracování threadingu přes coroutines je zásadní pro responsivní, korektní aplikace, a protože pochopení threading pravidel, jak správně přesunout práci mimo main thread a nebezpečí concurrency je nutná znalost platformy, je pochopení Android threadingu a concurrency důležitou znalostí na senior úrovni — ústředním prvkem při vytváření responsivních aplikací, řešení základních Android omezení a odráží odbornost platformy očekávanou od senior vývojářů, kteří musí zajistit, aby aplikace zůstaly responsivní při asynchronní práci, kterou skutečné aplikace vyžadují.