2013-10-08 21 views
6

Voglio sapere la differenza tra set() e compareAndSet() nelle classi atomiche. Il metodo set() garantisce anche il processo atomico? Ad esempio questo codice:Java Atomic set variabile() vs compareAndSet()

public class sampleAtomic{ 
    private static AtomicLong id = new AtomicLong(0); 

    public void setWithSet(long newValue){ 
     id.set(newValue); 
    } 

    public void setWithCompareAndSet(long newValue){ 
     long oldVal; 
     do{ 
      oldVal = id.get(); 
     } 
     while(!id.compareAndGet(oldVal,newValue) 
    } 
} 

I due metodi sono identici?

risposta

7

I set e compareAndSet metodi comportano diversamente:

  • compareAndSet: imposta il valore Atomicamente al dato valore aggiornato se il valore corrente è uguale (==) al valore atteso.
  • set: Imposta al valore dato.

Il metodo set() garantisce anche il processo atomico?

Sì. È atomico. Perché c'è solo una operazione coinvolta a set il nuovo valore. Di seguito è riportato il codice sorgente del metodo set:

public final void set(long newValue) { 
     value = newValue; 
} 
+0

Grazie per la risposta. Ho dimenticato di controllare il codice sorgente. Hai ragione nel dire che il metodo set è atomico, ma il motivo non è perché ha solo una operazione. Le classi automatiche hanno una variabile membro chiamata value e quella variabile è volatile (quella nel corpo del metodo set sopra), quindi il metodo set dovrebbe essere thread-safe. –

+2

Sei sicuro che le classi 'Atomic' sono atomiche perché usano variabili volatili per mantenere i loro stati interni. Se si definisce una variabile volatile 'volatile long value', un'operazione come' value ++ 'è atomica? E la risposta è no. Questa operazione non è atomica; in realtà sono tre operazioni distinte: recupera il valore, ne aggiunge uno, riporta il valore aggiornato. Nel frattempo, un altro thread può cambiare il valore. Quindi avere una variabile 'volatile' non garantisce l'atomicità. Un'operazione/processo è 'atomic', se forniscono supporto per gli aggiornamenti atomici. –

+1

Ora, l'opzione 'set' è atomica, perché ha una sola operazione:' value = newValue; 'ed è atomica anche se' value' non è definito 'volatile'. Qui 'value' è stato definito' volatile' per usare la garanzia di visibilità che forniscono - le modifiche apportate da un thread sono sempre visibili agli altri thread. –

-1

Come si può vedere dal codice JDK aperta sotto.

http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/atomic/AtomicLong.java#AtomicLong.set%28long%29

set è solo assegnando il valore e compareAndSet sta facendo operazioni in più per garantire l'atomicità.

http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/atomic/AtomicLong.java#AtomicLong.compareAndSet%28long%2Clong%29

Il valore di ritorno (booleano) deve essere considerato per la progettazione di eventuali operazioni atomiche.