Synchronizuj dostęp do zapisu do pola Volatile (tanie blokowanie odczytu i zapisu)

Question

Załóżmy, że mam następującą klasę, która będzie czytana intensywnie, ale tylko zapisywana okazjonalnie. Będzie on wykorzystywany w wielowątkowych aplikacji internetowej, więc to musi być bezpieczne wątek:

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

Java współbieżności (http://www.ibm.com/developerworks/java/library/j-jtp06197/index.html) stwierdza, że ​​jest to delikatny sposób, aby chronić dostęp do zapisu przy jednoczesnej poprawie odczytu. Czym jest silniejsza alternatywa dla tego wzoru? Lub jakąś alternatywę, jeśli foo będzie wymagało zmiany w środowisku ciężkim dla odczytu? Dziękuję Ci.

Answer 1

Lotny zapewnia szybki wątek bezpieczne lock-wolny dostęp do pola bez synchronizacji

private volatile String foo; 

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

nielotne rozwiązuje problemy 3 1) widoczności pamięć 2) zapisuje atomowych dla dwu- i długich polach 3) zakazuje praktykującym instrukcje reorganizację. Ale to nie wystarczy, jeśli potrzebujesz kilku operacji na polu jako jednej transakcji atomowej, takiej jak inkrementacja. Ten kod jest uszkodzony

private volatile int id; 

public void incrementId() { 
    id++; 
} 

bo jeśli 2 wątki simulataneously czytać i zwiększyć ją i zapisać wynik to wynik pierwszego przyrostu zostaną zastąpione w wyniku drugiej przyrostu. Aby temu zapobiec musimy użyć synchronizację

private int id; 

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

lub pakiet java.util.concurrent.atomic

private AtomicInteger id = new AtomicInteger(); 

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

Answer 2

Jeśli to ustawienie foo wszystko robisz, to nie trzeba synchronizować metoda. sprawdzenie lotności odniesienia jest wystarczające.

Answer 3

Na link pan powiedział, że jest to kod dla „rzadkie aktualizacje” Użycie:

@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++; 
    } 
} 

Sposób increment jest tylko przy użyciu zsynchronizowane bo robi więcej niż tylko ustawienie wartości value jak podano w opis, jeśli wszystko co robisz to this.foo = in;, który jest atomowy. W tekście "kruchość tego wzoru" oznacza, że ​​rzeczy mogą się bardzo szybko brudzić, gdy miesza się lotne i inne metody synchronizacji, aby zrobić coś więcej niż tylko proste przykłady. Zobacz pakiet java.util.concurrent.locks dla interfejsów Warunek i Blokowanie i klasy ReentrantLock. Myślę, że i używanie synchronizacji jest tym, co autor rozumie przez "mocniejsze alternatywy". Powinieneś także zobaczyć Object.wait, Object.notify i Object.notifyAll, jeśli jeszcze tego nie wiesz.