Kako rad sa nitima i konkurentnost funkcioniraju na Androidu?

Question

Accepted Answer

Android ima strogi **model rada sa nitima** centriran na **glavnoj (UI) niti** — koja mora rukovati sučeljem i ostati responzivna. Razumijevanje rada sa nitima, zašto se posao mora premjestiti sa glavne niti, i alati (coroutines, i istorijski threads/handlers) su važni za responzivne aplikacije.

## Pravilo glavne niti

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

## Premještanje posla sa glavne niti

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

## Alati za konkurentnost i razmatranja

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

## Zašto je važno

Razumijevanje Android rada sa nitima i konkurentnosti je važno znanje na razini seniora jer je **model glavne niti fundamentalan za Android**, a pravilan rad sa nitima je esencijalan za responzivne i ispravne aplikacije, pa je to vrijedna znanja o platformi.

Androidova **jednostavna glavna (UI) nit** — koja rukovati svim UI elementima i mora ostati responzivna — nametne dva fundamentalna pravila: **ne blokiraj glavnu nit** dugotrajnim/blokantnim poslovima (mreža, baza podataka, teški proračuni), jer blokiranje "smrzava" sučelje i uzrokuje **ANR** greške (česti problem), i **ne ažuriraj UI sa pozadinske niti** (UI ažuriranja moraju se desiti na glavnoj niti).

Razumijevanje ovih pravila je esencijalno jer njihova kršenja uzrokuju najčešće Android probleme (smrznuto sučelje, ANR greške, rušenja zbog ažuriranja UI-ja van niti).

Razumijevanje **kako pravilno premjestiti posao sa glavne niti** — moderni pristup koristeći **coroutines sa dispečerima** (pokretanje IO/teških poslova na pozadinskim dispečerima poput Dispatchers.IO, zatim vraćanje na glavnu nit za UI ažuriranja, sve unutar lifecycle-aware opsega) — je esencijalna praktična vještina za responzivne aplikacije, i predstavlja preporučeni, čist način rukovanja nitima.

Razumijevanje **alata za konkurentnost** (coroutines kao moderni standard; istorijski Thread/Handler/AsyncTask/RxJava za kontekst) i **rizika konkurentnosti** (race conditions, dijeljeno mutable stanje koje zahtijevasinizaciju ili izbjegavanje) pokazuje dublje razumijevanje potrebno za ispravnu konkurentnu kodu, i znanje da se poništi pozadinski rad preko lifecycle opsega sprječava curenja.

Pošto je model glavne niti fundamentalan za Android (blokiranje ga ili ažuriranje UI-ja van niti uzrokuju najčešće probleme) i pravilno rukovanje nitima preko coroutines je esencijalno za responzivne, ispravne aplikacije, i pošto je razumijevanje pravila rada sa nitima, kako pravilno premjestiti posao sa glavne niti, i rizika konkurentnosti potrebno znanje o platformi, razumijevanje Android rada sa nitima i konkurentnosti je važno znanje na razini seniora — centralno za izgradnju responzivnih aplikacija, rješavanje fundamentalnih Android ograničenja, i pokazivanje stručnjaka platforme očekivanog od seniora koji moraju osigurati da aplikacije ostanu responzivne dok rade asinkroni posao koji prave aplikacije trebaju.