Aller au contenu

Java — volatile

Le mot-clé volatile en Java est essentiel dès qu’on travaille avec plusieurs threads. Il permet d’éviter des bugs subtils liés à la mémoire et à la visibilité des données.

Idée simple

volatile garantit :

la visibilité des variables entre threads

Concrètement :

  • si un thread modifie une variable
  • les autres threads voient immédiatement la nouvelle valeur

Problème sans volatile

boolean running = true;

Thread t = new Thread(() -> {
    while (running) {
        // boucle infinie possible
    }
});

running = false;

Problème :

  • le thread peut ne jamais voir la mise à jour
  • il continue à tourner indéfiniment

💥 C’est un bug réel qu’on peut rencontrer en production

Solution avec volatile

volatile boolean running = true;

Maintenant :

  • chaque thread lit toujours la valeur à jour
  • la boucle peut s’arrêter correctement

Ce que fait vraiment volatile

volatile garantit :

  • ✔️ visibilité mémoire
  • ❌ pas d’atomicité

Piège majeur

Beaucoup pensent :

“volatile = thread-safe”

  • Faux

Exemple important

volatile int count = 0;

count++; // ❌ pas thread-safe

Pourquoi ?

count++ correspond à plusieurs étapes :

  1. lire la valeur
  2. l’incrémenter
  3. écrire le résultat

Avec plusieurs threads → conflits possibles

Résumé clé

Concept volatile
visibilité ✔️
atomicité ❌
lock ❌

Quand utiliser volatile

Bon cas

  • variables de type flag (running, stop)
  • état simple partagé
  • lecture/écriture sans logique complexe

Mauvais cas

  • compteur (count++)
  • opérations multiples
  • logique critique concurrente

Différence avec synchronized

volatile synchronized
visibilité ✔️ ✔️
atomicité ❌ ✔️
lock ❌ ✔️

Pièges fréquents

  • croire que volatile rend le code thread-safe
  • l’utiliser pour des compteurs
  • confondre visibilité et atomicité

Questions classiques

Q1

volatile garantit :

  • A. atomicité
  • B. visibilité
  • C. lock

Réponse : B

Q2

volatile int count = 0;
count++;

Thread-safe ?

Non

Q3

Pourquoi utiliser volatile ?

Pour partager une variable simple entre threads

À retenir

  • volatile rend les modifications visibles immédiatement
  • il ne protège pas contre les accès concurrents
  • pour des opérations complexes → utiliser synchronized ou des outils adaptés

🧾 En résumé

  • volatile garantit la visibilité entre threads
  • il ne garantit ni atomicité ni sécurité complète
  • il est utile pour des cas simples (flags, états)
  • il ne remplace pas les mécanismes de synchronisation

C’est un outil simple, mais crucial pour éviter certains bugs en environnement concurrent.

Voir aussi