Ist der Thread Thread! = Sicher?

Ich weiß, dass zusammengesetzte Operationen, wie sie i++nicht threadsicher sind, mehrere Operationen beinhalten.

Aber ist das Überprüfen der Referenz mit sich selbst eine thread-sichere Operation?

a != a //is this thread-safe

Ich habe versucht, dies zu programmieren und mehrere Threads zu verwenden, aber es ist nicht fehlgeschlagen. Ich konnte wohl kein Rennen auf meiner Maschine simulieren.

BEARBEITEN:

public class TestThreadSafety {
    private Object a = new Object();

    public static void main(String[] args) {

        final TestThreadSafety instance = new TestThreadSafety();

        Thread testingReferenceThread = new Thread(new Runnable() {

            @Override
            public void run() {
                long countOfIterations = 0L;
                while(true){
                    boolean flag = instance.a != instance.a;
                    if(flag)
                        System.out.println(countOfIterations + ":" + flag);

                    countOfIterations++;
                }
            }
        });

        Thread updatingReferenceThread = new Thread(new Runnable() {

            @Override
            public void run() {
                while(true){
                    instance.a = new Object();
                }
            }
        });

        testingReferenceThread.start();
        updatingReferenceThread.start();
    }

}

Dies ist das Programm, mit dem ich die Thread-Sicherheit teste.

Seltsames Verhalten

Wenn mein Programm zwischen einigen Iterationen startet, erhalte ich den Ausgabeflag-Wert, was bedeutet, dass die Referenzprüfung !=für dieselbe Referenz fehlschlägt. ABER nach einigen Iterationen wird die Ausgabe zu einem konstanten Wert, falseund wenn das Programm dann über einen langen Zeitraum ausgeführt wird, wird keine einzige trueAusgabe generiert .

Wie die Ausgabe nach einigen n (nicht festen) Iterationen andeutet, scheint die Ausgabe ein konstanter Wert zu sein und ändert sich nicht.

Ausgabe:

Für einige Iterationen:

1494:true
1495:true
1496:true
19970:true
19972:true
19974:true
//after this there is not a single instance when the condition becomes true

In Ermangelung einer Synchronisation dieser Code

Object a;

public boolean test() {
    return a != a;
}

kann produzieren true. Dies ist der Bytecode fürtest()

    ALOAD 0
    GETFIELD test/Test1.a : Ljava/lang/Object;
    ALOAD 0
    GETFIELD test/Test1.a : Ljava/lang/Object;
    IF_ACMPEQ L1
...

Wie wir sehen können, wird das Feld azweimal in lokale Variablen geladen. Es handelt sich um eine nichtatomare Operation, wenn sie azwischendurch durch einen anderen Thread-Vergleich geändert wurde false.

Auch das Problem der Speichersichtbarkeit ist hier relevant. Es gibt keine Garantie dafür, dass Änderungen, adie von einem anderen Thread vorgenommen wurden, für den aktuellen Thread sichtbar sind.

Ist der Scheck a != athreadsicher?

Wenn amöglicherweise von einem anderen Thread aktualisiert werden kann (ohne ordnungsgemäße Synchronisierung!), Dann Nein.

Ich habe versucht, dies zu programmieren und mehrere Threads zu verwenden, bin aber nicht gescheitert. Ich konnte wohl kein Rennen auf meiner Maschine simulieren.

Das hat nichts zu bedeuten! Das Problem ist, dass der Code nicht threadsicher ist, wenn eine Ausführung, die avon einem anderen Thread aktualisiert wird , vom JLS zugelassen wird. Die Tatsache, dass Sie nicht veranlassen können, dass die Race-Bedingung mit einem bestimmten Testfall auf einem bestimmten Computer und einer bestimmten Java-Implementierung auftritt, schließt dies unter anderen Umständen nicht aus.

Bedeutet dies , dass a! = A zurückkehren konnte true.

Ja, theoretisch unter bestimmten Umständen.

Alternativ a != akönnte zurückkehren false, obwohl asich gleichzeitig ändert.

In Bezug auf das "seltsame Verhalten":

Wenn mein Programm zwischen einigen Iterationen startet, erhalte ich den Ausgabeflag-Wert, was bedeutet, dass die Referenz! = Prüfung für dieselbe Referenz fehlschlägt. ABER nach einigen Iterationen wird die Ausgabe zu einem konstanten Wert false, und wenn das Programm dann über einen langen Zeitraum ausgeführt wird, wird keine einzige echte Ausgabe generiert.

Dieses "seltsame" Verhalten stimmt mit dem folgenden Ausführungsszenario überein:

1. Das Programm wird geladen und die JVM beginnt mit der Interpretation der Bytecodes. Da (wie wir aus der Javap-Ausgabe gesehen haben) der Bytecode zwei Ladevorgänge ausführt, sehen Sie (anscheinend) gelegentlich die Ergebnisse der Rennbedingung.

2. Nach einiger Zeit wird der Code vom JIT-Compiler kompiliert. Der JIT-Optimierer stellt fest, dass zwei Ladungen desselben Speichersteckplatzes ( a) nahe beieinander liegen, und optimiert den zweiten entfernt. (Tatsächlich besteht die Möglichkeit, dass der Test vollständig optimiert wird ...)

3. Jetzt manifestiert sich der Rennzustand nicht mehr, weil es keine zwei Lasten mehr gibt.

Beachten Sie, dass dies alles mit dem übereinstimmt, was das JLS einer Implementierung von Java ermöglicht.

@kriss kommentierte also:

Dies könnte das sein, was C- oder C ++ - Programmierer als "undefiniertes Verhalten" bezeichnen (implementierungsabhängig). Scheint, als ob es in Java-Fällen wie diesem ein paar UB in Java geben könnte.

Das Java-Speichermodell (in JLS 17.4 angegeben) gibt eine Reihe von Voraussetzungen an, unter denen ein Thread garantiert Speicherwerte sieht, die von einem anderen Thread geschrieben wurden. Wenn ein Thread versucht, eine von einem anderen geschriebene Variable zu lesen, und diese Voraussetzungen nicht erfüllt sind, kann es eine Reihe möglicher Ausführungen geben, von denen einige wahrscheinlich falsch sind (aus Sicht der Anforderungen der Anwendung). Mit anderen Worten, die Menge möglicher Verhaltensweisen (dh die Menge "wohlgeformter Ausführungen") ist definiert, aber wir können nicht sagen, welches dieser Verhaltensweisen auftreten wird.

Der Compiler kann Lasten kombinieren und neu anordnen und speichern (und andere Dinge tun), vorausgesetzt, der Endeffekt des Codes ist der gleiche:

• wenn von einem einzelnen Thread ausgeführt, und
• bei Ausführung durch verschiedene Threads, die korrekt synchronisiert werden (gemäß Speichermodell).

Wenn der Code jedoch nicht richtig synchronisiert wird (und daher die "Vorher" -Beziehungen die Menge der wohlgeformten Ausführungen nicht ausreichend einschränken), kann der Compiler Lasten und Speichern auf eine Weise neu anordnen, die "falsche" Ergebnisse liefert. (Aber das heißt wirklich nur, dass das Programm falsch ist.)

Bewiesen mit test-ng:

public class MyTest {

  private static Integer count=1;

  @Test(threadPoolSize = 1000, invocationCount=10000)
  public void test(){
    count = new Integer(new Random().nextInt());
    Assert.assertFalse(count != count);
  }

}

Ich habe 2 Fehler bei 10 000 Aufrufen. Also NEIN , es ist NICHT threadsicher

Nein ist es nicht. Für einen Vergleich muss die Java-VM die beiden zu vergleichenden Werte auf den Stapel legen und die Vergleichsanweisung ausführen (die vom Typ "a" abhängt).

Die Java-VM kann:

1. Lesen Sie zweimal "a", legen Sie jedes auf den Stapel und vergleichen Sie die Ergebnisse
2. Lesen Sie "a" nur einmal, legen Sie es auf den Stapel, duplizieren Sie es (Anweisung "dup") und führen Sie den Vergleich aus
3. Beseitigen Sie den Ausdruck vollständig und ersetzen Sie ihn durch false

Im ersten Fall könnte ein anderer Thread den Wert für "a" zwischen den beiden Lesevorgängen ändern.

Welche Strategie gewählt wird, hängt vom Java-Compiler und der Java-Laufzeit ab (insbesondere vom JIT-Compiler). Es kann sich sogar zur Laufzeit Ihres Programms ändern.

Wenn Sie sicherstellen möchten, wie auf die Variable zugegriffen wird, müssen Sie sie erstellen volatile(eine sogenannte "halbe Speicherbarriere") oder eine vollständige Speicherbarriere hinzufügen ( synchronized). Sie können auch eine API auf höherer Ebene verwenden (z. B. AtomicIntegerwie von Juned Ahasan erwähnt).

Weitere Informationen zur Thread-Sicherheit finden Sie in JSR 133 ( Java Memory Model ).

Stephen C. hat alles gut erklärt. Zum Spaß können Sie versuchen, denselben Code mit den folgenden JVM-Parametern auszuführen:

-XX:InlineSmallCode=0

Dies sollte die Optimierung durch die JIT verhindern (dies geschieht auf dem Hotspot 7-Server) und Sie werden es truefür immer sehen (ich habe bei 2.000.000 angehalten, aber ich nehme an, dass es danach fortgesetzt wird).

Zur Information finden Sie unten den JIT-Code. Um ehrlich zu sein, lese ich die Montage nicht fließend genug, um zu wissen, ob der Test tatsächlich durchgeführt wird oder woher die beiden Lasten stammen. (Zeile 26 ist der Test flag = a != aund Zeile 31 ist die schließende Klammer von while(true)).

  # {method} 'run' '()V' in 'javaapplication27/TestThreadSafety$1'
  0x00000000027dcc80: int3   
  0x00000000027dcc81: data32 data32 nop WORD PTR [rax+rax*1+0x0]
  0x00000000027dcc8c: data32 data32 xchg ax,ax
  0x00000000027dcc90: mov    DWORD PTR [rsp-0x6000],eax
  0x00000000027dcc97: push   rbp
  0x00000000027dcc98: sub    rsp,0x40
  0x00000000027dcc9c: mov    rbx,QWORD PTR [rdx+0x8]
  0x00000000027dcca0: mov    rbp,QWORD PTR [rdx+0x18]
  0x00000000027dcca4: mov    rcx,rdx
  0x00000000027dcca7: movabs r10,0x6e1a7680
  0x00000000027dccb1: call   r10
  0x00000000027dccb4: test   rbp,rbp
  0x00000000027dccb7: je     0x00000000027dccdd
  0x00000000027dccb9: mov    r10d,DWORD PTR [rbp+0x8]
  0x00000000027dccbd: cmp    r10d,0xefc158f4    ;   {oop('javaapplication27/TestThreadSafety$1')}
  0x00000000027dccc4: jne    0x00000000027dccf1
  0x00000000027dccc6: test   rbp,rbp
  0x00000000027dccc9: je     0x00000000027dcce1
  0x00000000027dcccb: cmp    r12d,DWORD PTR [rbp+0xc]
  0x00000000027dcccf: je     0x00000000027dcce1  ;*goto
                                                ; - javaapplication27.TestThreadSafety$1::run@62 (line 31)
  0x00000000027dccd1: add    rbx,0x1            ; OopMap{rbp=Oop off=85}
                                                ;*goto
                                                ; - javaapplication27.TestThreadSafety$1::run@62 (line 31)
  0x00000000027dccd5: test   DWORD PTR [rip+0xfffffffffdb53325],eax        # 0x0000000000330000
                                                ;*goto
                                                ; - javaapplication27.TestThreadSafety$1::run@62 (line 31)
                                                ;   {poll}
  0x00000000027dccdb: jmp    0x00000000027dccd1
  0x00000000027dccdd: xor    ebp,ebp
  0x00000000027dccdf: jmp    0x00000000027dccc6
  0x00000000027dcce1: mov    edx,0xffffff86
  0x00000000027dcce6: mov    QWORD PTR [rsp+0x20],rbx
  0x00000000027dcceb: call   0x00000000027a90a0  ; OopMap{rbp=Oop off=112}
                                                ;*aload_0
                                                ; - javaapplication27.TestThreadSafety$1::run@2 (line 26)
                                                ;   {runtime_call}
  0x00000000027dccf0: int3   
  0x00000000027dccf1: mov    edx,0xffffffad
  0x00000000027dccf6: mov    QWORD PTR [rsp+0x20],rbx
  0x00000000027dccfb: call   0x00000000027a90a0  ; OopMap{rbp=Oop off=128}
                                                ;*aload_0
                                                ; - javaapplication27.TestThreadSafety$1::run@2 (line 26)
                                                ;   {runtime_call}
  0x00000000027dcd00: int3                      ;*aload_0
                                                ; - javaapplication27.TestThreadSafety$1::run@2 (line 26)
  0x00000000027dcd01: int3   

Nein, a != aist nicht threadsicher. Dieser Ausdruck besteht aus drei Teilen: Laden a, aerneut laden und ausführen !=. Es ist möglich, dass ein anderer Thread die intrinsische Sperre für adas übergeordnete Element erhält und den Wert azwischen den beiden Ladevorgängen ändert .

Ein weiterer Faktor ist jedoch, ob aes sich um eine lokale handelt. Wenn aes lokal ist, sollten keine anderen Threads Zugriff darauf haben und daher threadsicher sein.

void method () {
    int a = 0;
    System.out.println(a != a);
}

sollte auch immer drucken false.

Deklarieren aals volatilewürde das Problem für if ais staticoder instance nicht lösen . Das Problem ist nicht, dass Threads unterschiedliche Werte von haben a, sondern dass ein Thread azweimal mit unterschiedlichen Werten geladen wird. Dies kann dazu führen, dass der Fall weniger threadsicher ist. Wenn dies anicht der Fall ist, wird volatileer amöglicherweise zwischengespeichert, und eine Änderung in einem anderen Thread wirkt sich nicht auf den zwischengespeicherten Wert aus.

In Bezug auf das seltsame Verhalten:

Da die Variable anicht als markiert ist volatile, wird der Wert von amöglicherweise irgendwann vom Thread zwischengespeichert. Beide as a != asind dann die zwischengespeicherte Version und somit immer gleich (Bedeutung flagist jetzt immer false).

Selbst einfaches Lesen ist nicht atomar. Wenn aist longund nicht als volatiledann markiert, ist bei 32-Bit-JVMs long b = anicht threadsicher.