Ist eine Synchronisierung beim Lesen erforderlich, wenn keine Konflikte auftreten können?

Question

Beachten Sie den nachstehenden Code Sniper:

package sync;

public class LockQuestion {
    private String mutable;

    public synchronized void setMutable(String mutable) {
        this.mutable = mutable;
    }

    public String getMutable() {
        return mutable;
    }   
}

Zum Zeitpunkt Time1 wird Thread1 die Variable "mutable" aktualisieren. Die Synchronisierung ist im Setter erforderlich, um den Speicher vom lokalen Cache in den Hauptspeicher zu leeren. Zum Zeitpunkt Time2 (Time2 > Time1, keine Thread-Konkurrenz) liest Thread Thread2 den Wert der Variable mutable.

Frage ist - muss ich synchronized vor getter setzen? Sieht aus wie dies wird keine Probleme verursachen - Speicher sollte aktuell sein und Thread2's lokalen Cache-Speicher sollte ungültig & aktualisiert von Thread1, aber ich bin nicht sicher.

Answer 1

Anstatt sich zu fragen, warum man nicht einfach die atomaren Referenzen in java.util.concurrent ?

(und falls es etwas wert ist, meine Lektüre von passiert-vor garantiert nicht, dass Thread2 Änderungen an mutable sieht, es sei denn, er verwendet auch synchronized ... aber dieser Teil der JLS bereitet mir immer Kopfschmerzen, also verwende ich die atomaren Referenzen)

Answer 2

Es ist in Ordnung, wenn Sie mutable flüchtig machen, Details in der " billige Schreib-Lese-Sperre "

Answer 3

Sind Sie absolut sicher, dass der Getter erst aufgerufen wird, nachdem der Setter aufgerufen wurde? Wenn ja, brauchen Sie den Getter nicht zu synchronisieren, da gleichzeitige Lesevorgänge nicht synchronisiert werden müssen.

Wenn die Möglichkeit besteht, dass get und set gleichzeitig aufgerufen werden können, müssen Sie die beiden definitiv synchronisieren.

Answer 4

Wenn Sie sich so sehr um die Leistung im Lesethread sorgen, dann lesen Sie den Wert nur einmal mit der richtigen Synchronisierung oder flüchtigen oder atomaren Referenzen. Dann weisen Sie den Wert einer einfachen alten Variablen zu.

Die Zuweisung an die einfache Variable erfolgt garantiert nach dem atomaren Lesen (denn wie sonst könnte sie den Wert erhalten?), und wenn der Wert nie wieder von einem anderen Thread geschrieben wird, ist alles in Ordnung.

Answer 5

Ich denke, Sie sollten mit etwas beginnen, das korrekt ist, und später optimieren, wenn Sie wissen, dass Sie ein Problem haben. Ich würde einfach AtomicReference verwenden, es sei denn, ein paar Nanosekunden sind zu lang ;)

public static void main(String... args) {
    AtomicReference<String> ars = new AtomicReference<String>();
    ars.set("hello");
    long start = System.nanoTime();
    int runs = 1000* 1000 * 1000;
    int length = test(ars, runs);
    long time = System.nanoTime() - start;
    System.out.printf("get() costs " + 1000*time / runs + " ps.");
}

private static int test(AtomicReference<String> ars, int runs) {
    int len = 0;
    for (int i = 0; i < runs; i++)
        len = ars.get().length();
    return len;
}

Drucke

get() costs 1219 ps.

ps ist eine Pikosekunde, mit ist 1 Millionstel einer Mikrosekunde.