Qual è la differenza tra coerenza sequenziale e atomicità?

Question

Ho letto che java volatile è sequenziale coerente ma non atomico. Per atomicity java fornisce una libreria diversa.

Qualcuno può spiegare la differenza tra due, in inglese semplice?

(credo che il campo di applicazione domanda comprende C/C++ e quindi l'aggiunta di questi tag di lingua per ottenere più grande pubblico.)

Answer 1

Immaginate queste due variabili in una classe:

int i = 0; 
volatile int v = 0; 

E quei due metodi

void write() { 
    i = 5; 
    v = 2; 
} 

void read() { 
    if (v == 2) { System.out.println(i); } 
} 

La semantica volatili garantire che read saranno sia di stampa 5 o niente (supponendo che non altri metodi stanno modificando il campi ovviamente). Se v non fosse volatile, read potrebbe anche stampare 0 perché i = 5 e v = 2 potrebbero essere stati riordinati. Immagino che questo sia ciò che intendi per consistenza sequenziale, che ha un significato più ampio.

D'altra parte, volatile non garantisce l'atomicità. Quindi, se due thread chiamano questo metodo in concomitanza (v è la stessa volatile int):

void increment() { 
    v++; 
} 

si ha alcuna garanzia che V sarà incrementato di 2. Questo perché v++ è in realtà tre affermazioni:

load v; 
increment v; 
store v; 

ea causa di interleaving di thread v potrebbe essere incrementato solo una volta (entrambi i thread caricheranno lo stesso valore).

Answer 2

Supponiamo di avere queste due variabili:

public int a = 0; 
public volatile int b = 0; 

e supponiamo un thread fa

a = 1; 
b = 2; 

Se un altro thread legge questi valori e vede che b == 2, quindi è garantito per vedere anche a == 1.

Ma il thread di lettura potrebbe vedere a == 1 e b == 0, poiché le due scritture non fanno parte di un'operazione atomica, quindi il thread di lettura potrebbe vedere la modifica apportata a a prima che il primo thread abbia assegnato un valore a .

di rendere questi due scritture atomica, si avrebbe bisogno di sincronizzare l'accesso a queste due variabili:

synchronized (lock) { 
    a = 1; 
    b = 2; 
} 

... 

synchronized (lock) { 
    System.out.println("a = " + a + "; b = " + b); 
} 

E in questo caso, il filo di lettura vedrà a == 0 e b == 0, o a == 1 e b == 2, ma mai lo stato intermedio.