Comment fonctionne la gestion de la mémoire dans Android et comment éviter les fuites ?

Question

Accepted Answer

Les applications Android s'exécutent avec **une mémoire limitée** et sont sujettes à l'arrêt par le système en cas de pression mémoire. Comprendre la gestion de la mémoire — et en particulier **éviter les fuites mémoire** (un problème Android courant et sérieux) — est important pour des applications stables et performantes.

## Notions de base sur la mémoire Android

```text
→ Apps have a LIMITED heap; the system can KILL background apps to reclaim memory
→ Garbage collection reclaims unreachable objects — but GC pauses can cause jank, and
  objects that STAY reachable (leaks) are never collected
→ Low-memory devices are common (Android's range) → memory efficiency matters
```

## Les fuites mémoire — le problème courant

```text
A LEAK = an object that's no longer needed but is still REFERENCED (so GC can't free it).
Classic Android leaks:
  ✗ Holding an ACTIVITY/Context reference beyond its lifecycle:
    - a static field or singleton holding an Activity/Context
    - a long-lived listener/callback capturing an Activity
    - an inner class / non-cancelled coroutine / handler holding the Activity
  → the Activity can't be GC'd after it's destroyed → its whole view tree leaks (big!)
```

## Éviter les fuites

```text
✓ Don't hold Activity/Context in static fields or long-lived objects (use applicationContext
  where a long-lived context is needed)
✓ UNREGISTER listeners/observers; CANCEL coroutines (lifecycle scopes auto-cancel)
✓ Use LIFECYCLE-AWARE components (ViewModel, lifecycleScope, LiveData) — they clean up
✓ Be careful with inner classes/handlers (use weak references or static + WeakReference)
✓ DETECT with LeakCanary (flags leaks in development); profile memory in Android Studio
```

## Pourquoi c'est important

Comprendre la gestion de la mémoire Android et éviter les fuites est une connaissance importante de niveau senior car **les fuites mémoire sont un problème Android courant et sérieux** qui dégrade les performances et cause des plantages, et l'environnement à mémoire limitée d'Android où le système tue les applications rend l'efficacité mémoire importante, donc c'est utile pour construire des applications stables.

Les applications Android s'exécutent avec **une mémoire limitée** et le système peut tuer les applications en cas de pression mémoire, tandis que le garbage collection récupère les objets inaccessibles mais ne peut pas libérer les objets qui restent référencés (fuites) — rendant la gestion mémoire importante, d'autant plus étant donné les nombreux appareils Android à faible mémoire. **Les fuites mémoire sont un problème Android particulièrement courant et impactant** : un objet qui n'est plus utile mais toujours référencé ne peut pas être garbage-collecté, et **les fuites Android classiques impliquent de conserver des références Activity/Context au-delà de leur cycle de vie** (via des champs statiques, des singletons, des listeners longue durée, des classes internes, des handlers, ou des coroutines non annulées capturant une Activity) — ce qui est particulièrement grave car une Activity fuitée entraîne tout son arbre de vues, une grande fuite mémoire.

Comprendre ces patterns de fuite est important car ce sont des sources fréquentes et réelles de problèmes de mémoire et de plantages.

Comprendre **comment éviter les fuites** — ne pas conserver Activity/Context dans des objets statiques ou longue durée (utiliser applicationContext le cas échéant), se désinscrire des listeners et annuler les coroutines (les lifecycle scopes s'annulent automatiquement), utiliser **des composants sensibles au cycle de vie** (ViewModel, lifecycleScope, LiveData qui nettoient automatiquement), être prudent avec les classes internes/handlers, et **détecter les fuites avec LeakCanary** et profiler — est la connaissance pratique essentielle pour les prévenir.

Étant donné que les fuites mémoire sont un problème Android courant et sérieux (en particulier les fuites Activity/Context) et que l'environnement à mémoire limitée d'Android rend l'efficacité importante, et puisque comprendre la gestion de la mémoire et les patterns à éviter (composants sensibles au cycle de vie, nettoyage approprié, outils de détection) est nécessaire pour des applications stables et performantes, comprendre la gestion de la mémoire Android et l'évitement des fuites est une connaissance importante de niveau senior — abordant l'un des problèmes Android les plus courants et impactants, reflétant l'expertise spécifique à la plateforme nécessaire pour construire des applications stables et la profondeur attendue pour les rôles Android senior.