Qu'est-ce que le mot-clé volatile en Java et comment l'utiliser?

volatile garantit la visibilité des modifications d'une variable pour tous les threads.

• Garantie de visibilité : Lorsqu'un thread modifie une variable volatile, les autres threads voient garantis cette modification. Sans volatile, les modifications peuvent rester dans le cache du thread, sans se synchroniser avec la mémoire principale.
• Pas atomique : volatile ne garantit pas l'atomicité des opérations. Les opérations comme l'incrément (i++) ne sont pas atomiques et peuvent entraîner des conditions de course même avec volatile.

Utilisé pour :

• Drapeaux d'état : Lorsqu'un thread définit un drapeau pour informer les autres threads d'un certain état.
• Opérations simples de lecture/écriture : Lorsque les opérations sur une variable consistent en une seule écriture par un thread et plusieurs lectures par d'autres.

Exemple d'utilisation avec un drapeau :

// Exemple d'utilisation de volatile pour un drapeau de terminaison
public class VolatileExample {
    private volatile boolean terminated = false;

    public void start() {
        new Thread(() -> {
            while (!terminated) {
                // Travail du thread
                System.out.println("Le thread fonctionne...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("Thread terminé.");
        }).start();
    }

    public void stop() {
        terminated = true; // Changement de la variable volatile
    }

    public static void main(String[] args) throws InterruptedException {
        VolatileExample example = new VolatileExample();
        example.start();
        Thread.sleep(500);
        example.stop();
    }
}