Jak działają wielowątkowość i współbieżność w systemie Android?

Question

Accepted Answer

Android ma ścisły **model wielowątkowości** skoncentrowany na **głównym wątku (UI)** — który musi obsługiwać interfejs użytkownika i pozostawać responsywny. Zrozumienie wielowątkowości, dlaczego prace muszą być przeniesione z głównego wątku oraz dostępnych narzędzi (coroutines i historycznie threads/handlers) jest ważne dla responsywnych aplikacji.

## Reguła głównego wątku

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

## Przenoszenie pracy z głównego wątku

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

## Narzędzia współbieżności i uwagi

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

## Dlaczego to ważne

Zrozumienie wielowątkowości i współbieżności w systemie Android jest ważną wiedzą na poziomie senior, ponieważ **model głównego wątku jest fundamentalny dla systemu Android**, a prawidłowe obsługiwanie wielowątkowości jest niezbędne dla responsywnych i poprawnych aplikacji, dlatego jest cenną wiedzą platformy.

Android ma **pojedynczy główny wątek (UI)** — który obsługuje cały interfejs użytkownika i musi pozostawać responsywny — narzuca dwie fundamentalne reguły: **nie blokuj głównego wątku** długą/blokującą pracą (sieć, baza danych, ciężkie obliczenia), ponieważ blokowanie zamraża interfejs użytkownika i powoduje błędy **ANR** (najczęstszy problem), oraz **nie aktualizuj interfejsu użytkownika z wątku tła** (aktualizacje interfejsu użytkownika muszą odbywać się na głównym wątku).

Zrozumienie tych reguł jest niezbędne, ponieważ ich naruszenie powoduje najczęstsze problemy w systemie Android (zamarznięty interfejs użytkownika, błędy ANR, awarie spowodowane aktualizacją interfejsu z wątku poza głównym).

Zrozumienie **jak prawidłowo przenieść pracę z głównego wątku** — nowoczesne podejście używające **coroutines z dispatcherami** (uruchamianie pracy IO/ciężkiej na dispatcherach tła takich jak Dispatchers.IO, następnie powrót do głównego wątku dla aktualizacji interfejsu użytkownika, wszystko w zakresach świadomych cyklu życia) — jest niezbędną praktyczną umiejętnością dla responsywnych aplikacji i reprezentuje rekomendowany, czysty sposób obsługi wielowątkowości.

Zrozumienie **narzędzi współbieżności** (coroutines jako nowoczesny standard; historyczne Thread/Handler/AsyncTask/RxJava dla kontekstu) oraz **zagrożeń współbieżności** (warunki wyścigu, współdzielony stan mutowalny wymagający synchronizacji lub unikania) odzwierciedla głębsze zrozumienie potrzebne do prawidłowego kodu współbieżnego, a wiedza o anulowaniu pracy w tle poprzez zakresy cyklu życia zapobiega wyciekom.

Ponieważ model głównego wątku jest fundamentalny dla systemu Android (zablokowanie go lub aktualizacja interfejsu użytkownika z wątku poza głównym powodując najczęstsze problemy) i prawidłowe obsługiwanie wielowątkowości poprzez coroutines jest niezbędne dla responsywnych, poprawnych aplikacji, a zrozumienie reguł wielowątkowości, jak prawidłowo przenieść pracę z głównego wątku i zagrożeń współbieżności jest niezbędną wiedzą platformy, zrozumienie wielowątkowości i współbieżności w systemie Android jest ważną wiedzą na poziomie senior — kluczową do budowania responsywnych aplikacji, sprostania fundamentalnym ograniczeniom systemu Android i odzwierciedlającej expertise platformy oczekiwaną od osób na poziomie senior, które muszą zapewnić, że aplikacje pozostają responsywne podczas wykonywania asynchronicznej pracy, którą wymagają rzeczywiste aplikacje.