Qual è la differenza tra l'uso di una primitiva volatile rispetto alle variabili atomiche?

Question

Eventuali duplicati:
Java: volatile boolean vs AtomicBoolean

Quando è opportuno utilizzare un volatile primitiva (ad esempio boolean, integer o long) anziché AtomicBoolean, AtomicInteger o AtomicLong, e viceversa?

Answer 1

La semantica della visibilità è esattamente la stessa, la situazione in cui è utile utilizzare i primitivi atomici è quando è necessario utilizzare i loro metodi atomici.

Ad esempio:

if (volatileBoolean) { 
    volatileBoolean = !volatileBoolean; 
} 

potrebbe creare problemi in un ambiente multi threaded come variabile potrebbe cambiare tra le due linee. Se è necessario l'assegnazione di prova & essere atomica, è possibile utilizzare:

atomicBoolean.compareAndSet(true, false); 

Answer 2

usando una pianura volatili è più semplice e più efficiente, se tutto quello che vogliamo fare è impostare o ottenere il valore. (Ma non ottenere & impostare il valore)

Se si desidera più operazioni come getAndIncrement o compareAndSwap è necessario utilizzare le classi AtomicXxxx.

Answer 3

Abbiamo iniziato a vietare l'uso di volatile nelle nostre fonti perché è molto semplice scrivere codice che non sempre funziona come previsto.

Nella mia esperienza, le persone aggiungono volatilità per condividere un valore tra i thread. E poi, qualcun altro inizia a modificare il valore. E la maggior parte delle volte funziona. Ma in produzione, inizi a ottenere errori strani che sono davvero difficili da rintracciare. I contatori vengono incrementati di 100'000 volte (i test li incrementano solo 10 volte) ma finiscono a 99'997. In Java 1.4, i valori lunghi potrebbero essere corrotti davvero, molto raramente.

Le classi di supporto Atomic*, d'altra parte, solo imporre un piccolo overhead e funzionano sempre come pubblicizzato.

Quindi, se non avete una buona ragione (*) da utilizzare volatile, preferire sempre le classi di supporto Atomic*.

Se non si sa esattamente che cosa ogni personaggio nelle classi di supporto Atomic* fa, allora si dovrebbe davvero evitare di volatile.

*: l'ottimizzazione prematura non è mai una buona ragione.

Answer 4

Le classi Atomic* avvolgono una primitiva volatile dello stesso tipo. Dalla fonte:

public class AtomicLong extends Number implements java.io.Serializable { 
    ... 
    private volatile long value; 
    ... 
    public final long get() { 
     return value; 
    } 
    ... 
    public final void set(long newValue) { 
     value = newValue; 
    } 

Così.

Quando è opportuno utilizzare una primitiva volatile (ad es.booleano, intero o lunga) al posto di AtomicBoolean, AtomicInteger o AtomicLong

Se tutti si sta facendo è ottenere e impostare un Atomic* allora si potrebbe anche semplicemente avere un campo volatile invece.

... e viceversa?

Quello che i Atomic* classi che danno tuttavia, sono metodi che forniscono funzionalità più avanzate come ad esempio incrementAndGet(), compareAndSet(), e altri che implementano operazioni multiple (get/incremento/set, test/set) senza bloccaggio. Ecco perché le classi Atomic* sono così potenti.

È anche importante notare che il wrapping del campo volatile utilizzando la classe Atomic* è un buon modo per incapsulare la risorsa condivisa fondamentale da un punto di vista dell'oggetto. Ciò significa che gli sviluppatori non possono semplicemente occuparsi del campo assumendo che non sia condiviso, eventualmente iniettando problemi con uno field++; o altro codice che introduce condizioni di competizione.