Sincronizza accesso in scrittura al campo Volatile (blocco di lettura/scrittura economico)

Question

Diciamo che ho la seguente classe che verrà letta pesantemente, ma solo scritta occasionalmente. Sarà usato in una web app multi-threaded, quindi ha bisogno di essere thread-safe:

public class Foo { 
    private volatile String foo; 
    public String getFoo() { 
     return foo; 
    } 
    public synchronized String setFoo(String in) { 
     this.foo = in; 
    } 
} 

Java Concurrency (http://www.ibm.com/developerworks/java/library/j-jtp06197/index.html) afferma che questo è un modo fragile per proteggere l'accesso in scrittura, migliorando l'accesso in lettura. Qual è un'alternativa più forte a questo modello? O qualsiasi alternativa se foo avrà bisogno di essere trasformato in un ambiente pesante da leggere? Grazie.

Answer 1

Volatile fornisce rapido accesso senza blocchi thread-safe a un campo senza sincronizzazione

private volatile String foo; 

public String getFoo() { 
    return foo; 
} 
public void setFoo(String in) { 
    this.foo = in; 
} 

risolve volatili 3 problemi 1) visibilità memoria 2) scrive atomici per campi doppie e lunghe 3) vieta istruzioni riordino. Ma non è abbastanza se hai bisogno di più operazioni su un campo come una transazione atomica, come l'incremento. Questo codice è rotto

private volatile int id; 

public void incrementId() { 
    id++; 
} 

perché se 2 fili simulataneously leggere e incrementarlo e per salvare il risultato allora il risultato del primo incremento viene sovrascritto con il risultato del secondo incremento. Per evitare che ciò accada abbiamo bisogno di usare la sincronizzazione

private int id; 

public synchronized int nextId() { 
     return ++id; 
} 

o un pacchetto java.util.concurrent.atomic

private AtomicInteger id = new AtomicInteger(); 

public void incrementId() { 
    return id.incrementAndGet(); 
} 

Answer 2

Se tutti si sta facendo è l'impostazione foo, allora non è necessario sincronizzare il metodo. rendere il riferimento volatile è sufficiente.

Answer 3

Al link hai detto c'è questo codice per "aggiornamenti poco frequenti" Utilizzo:

@ThreadSafe 
public class CheesyCounter { 
    // Employs the cheap read-write lock trick 
    // All mutative operations MUST be done with the 'this' lock held 
    @GuardedBy("this") private volatile int value; 

    public int getValue() { return value; } 

    public synchronized int increment() { 
     return value++; 
    } 
} 

Il metodo increment è solo utilizzando sincronizzato perché sta facendo più di un semplice impostare il valore della value come indicato nel descrizione, se tutto quello che stai facendo è this.foo = in; che è atomico. Nel testo la "fragilità di questo schema" indica che le cose possono diventare molto veloci quando si mescolano metodi volatili e altri metodi di sincronizzazione per fare qualcosa di più che semplici esempi. Vedi java.util.concurrent.locks pacchetti per le interfacce Condizione e blocco e la classe ReentrantLock. Penso che, e usando sincronizzato sia ciò che l'autore intende per "alternative più forti". Dovresti anche vedere Object.wait, Object.notify e Object.notifyAll se non lo sapevi ancora.