Cos'è la parola chiave volatile in Java e come viene usata?

volatile garantisce la visibilità delle modifiche di una variabile a tutti i thread.

• Garanzia di visibilità: Quando un thread modifica una variabile volatile, gli altri thread vedranno garantito questo cambiamento. Senza volatile, le modifiche possono rimanere nella cache del thread, senza sincronizzarsi con la memoria principale.
• Non atomico: volatile non garantisce l'atomicità delle operazioni. Operazioni come l'incremento (i++) non sono atomiche e possono portare a condizioni di race anche con volatile.

Usato per:

• Flag di stato: Quando un thread imposta un flag per comunicare ad altri thread uno stato.
• Operazioni di lettura/scrittura semplici: Quando le operazioni sulla variabile consistono in una singola scrittura da parte di un thread e molteplici letture da parte di altri.

Esempio di utilizzo con un flag:

// Esempio di utilizzo di volatile per un flag di terminazione
public class VolatileExample {
    private volatile boolean terminated = false;

    public void start() {
        new Thread(() -> {
            while (!terminated) {
                // Lavoro del thread
                System.out.println("Il thread è in esecuzione...");
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
            System.out.println("Thread terminato.");
        }).start();
    }

    public void stop() {
        terminated = true; // Cambio della variabile volatile
    }

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