Comment fonctionnent les threads et la concurrence sur Android ?

Question

Accepted Answer

Android possède un strict **modèle de threading** centré sur le **thread principal (UI)** — qui doit gérer l'interface utilisateur et rester réactif. Comprendre le threading, pourquoi le travail doit s'exécuter en dehors du thread principal, et les outils (coroutines, et historiquement threads/handlers) est important pour des applications réactives.

## La règle du thread principal

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

## Déplacer le travail en dehors du thread principal

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

## Outils de concurrence et considérations

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

## Pourquoi c'est important

Comprendre le threading et la concurrence sur Android est une connaissance importante au niveau senior car le **modèle single thread principal (UI)** est fondamental sur Android, et gérer correctement le threading est essentiel pour des applications réactives et correctes, ce qui en fait une connaissance précieuse de la plateforme.

Le **unique thread principal (UI)** d'Android — qui gère toute l'interface utilisateur et doit rester réactif — impose deux règles fondamentales : **ne pas bloquer le thread principal** avec un travail long ou bloquant (réseau, base de données, calcul lourd), car le bloquer gèle l'interface utilisateur et provoque des erreurs **ANR** (un problème majeur), et **ne pas mettre à jour l'interface utilisateur depuis un thread d'arrière-plan** (les mises à jour d'interface utilisateur doivent se faire sur le thread principal).

Comprendre ces règles est essentiel car les violer provoque les problèmes Android les plus courants (interfaces figées, ANR, crashes dus à des mises à jour d'interface utilisateur hors thread).

Comprendre **comment déplacer correctement le travail en dehors du thread principal** — l'approche moderne utilisant les **coroutines avec dispatchers** (exécuter le travail E/S et lourd sur des dispatchers d'arrière-plan comme Dispatchers.IO, puis revenir au thread principal pour les mises à jour d'interface utilisateur, le tout dans des scopes conscients du cycle de vie) — est la compétence pratique essentielle pour des applications réactives, et représente la manière recommandée et propre de gérer le threading.

Comprendre les **outils de concurrence** (coroutines comme standard moderne ; Thread/Handler/AsyncTask/RxJava historiquement pour le contexte) et les **risques de concurrence** (conditions de course, état mutable partagé nécessitant une synchronisation ou un évitement) reflète la compréhension plus profonde nécessaire pour un code concurrent correct, et savoir annuler le travail d'arrière-plan via les scopes de cycle de vie prévient les fuites.

Puisque le modèle thread principal est fondamental sur Android (le bloquer ou mettre à jour l'interface utilisateur hors thread causant les problèmes les plus courants) et que gérer correctement le threading via coroutines est essentiel pour des applications réactives et correctes, et puisque comprendre les règles de threading, comment déplacer correctement le travail en dehors du thread principal, et les risques de concurrence est une connaissance nécessaire de la plateforme, comprendre le threading et la concurrence sur Android est une connaissance importante au niveau senior — centrale pour construire des applications réactives, répondre aux contraintes fondamentales d'Android, et reflétant l'expertise de la plateforme attendue pour les rôles senior qui doivent assurer que les applications restent réactives tout en effectuant le travail asynchrone que les vraies applications nécessitent.