Warum ist i ++ nicht atomar?

Warum ist i++Java nicht atomar?

Um etwas tiefer in Java einzusteigen, habe ich versucht zu zählen, wie oft die Schleife in Threads ausgeführt wird.

Also habe ich eine verwendet

private static int total = 0;

in der Hauptklasse.

Ich habe zwei Threads.

• Thread 1: Drucke System.out.println("Hello from Thread 1!");
• Thread 2: Drucke System.out.println("Hello from Thread 2!");

Und ich zähle die Zeilen, die von Thread 1 und Thread 2 gedruckt wurden. Aber die Zeilen von Thread 1 + Zeilen von Thread 2 stimmen nicht mit der Gesamtzahl der ausgedruckten Zeilen überein.

Hier ist mein Code:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.logging.Level;
import java.util.logging.Logger;

public class Test {

    private static int total = 0;
    private static int countT1 = 0;
    private static int countT2 = 0;
    private boolean run = true;

    public Test() {
        ExecutorService newCachedThreadPool = Executors.newCachedThreadPool();
        newCachedThreadPool.execute(t1);
        newCachedThreadPool.execute(t2);
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        run = false;
        try {
            Thread.sleep(1000);
        }
        catch (InterruptedException ex) {
            Logger.getLogger(Test.class.getName()).log(Level.SEVERE, null, ex);
        }
        System.out.println((countT1 + countT2 + " == " + total));
    }

    private Runnable t1 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT1++;
                System.out.println("Hello #" + countT1 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    private Runnable t2 = new Runnable() {
        @Override
        public void run() {
            while (run) {
                total++;
                countT2++;
                System.out.println("Hello #" + countT2 + " from Thread 2! Total hello: " + total);
            }
        }
    };

    public static void main(String[] args) {
        new Test();
    }
}

i++ist in Java wahrscheinlich nicht atomar, da Atomizität eine spezielle Anforderung ist, die in den meisten Anwendungen von nicht vorhanden ist i++. Diese Anforderung hat einen erheblichen Overhead: Es ist mit hohen Kosten verbunden, eine Inkrementierungsoperation atomar zu machen. Es beinhaltet die Synchronisation sowohl auf Software- als auch auf Hardwareebene, die nicht in einem normalen Inkrement vorhanden sein müssen.

Sie könnten das Argument, i++das entworfen und dokumentiert werden sollte, als spezifisch für die Ausführung eines atomaren Inkrements festlegen, damit ein nicht-atomares Inkrement mit ausgeführt wird i = i + 1. Dies würde jedoch die "kulturelle Kompatibilität" zwischen Java und C und C ++ beeinträchtigen. Außerdem würde es eine bequeme Notation wegnehmen, die Programmierer, die mit C-ähnlichen Sprachen vertraut sind, für selbstverständlich halten, und ihr eine besondere Bedeutung geben, die nur unter bestimmten Umständen gilt.

Grundlegender C- oder C ++ - Code wie for (i = 0; i < LIMIT; i++)würde in Java übersetzt werden als for (i = 0; i < LIMIT; i = i + 1); weil es unangemessen wäre, das Atom zu verwenden i++. Was noch schlimmer ist, Programmierer, die von C oder anderen C-ähnlichen Sprachen zu Java kommen, würden i++sowieso verwenden, was zu einer unnötigen Verwendung atomarer Anweisungen führen würde.

Selbst auf der Ebene des Maschinenbefehlssatzes ist eine Inkrementoperation aus Leistungsgründen normalerweise nicht atomar. In x86 muss eine spezielle Anweisung "Sperrpräfix" verwendet werden, um die incAnweisung atomar zu machen : aus den gleichen Gründen wie oben. Wenn inces immer atomar wäre, würde es niemals verwendet werden, wenn eine nichtatomare Inc erforderlich ist; Programmierer und Compiler würden Code generieren, der lädt, 1 hinzufügt und speichert, weil er viel schneller wäre.

In einigen Befehlssatzarchitekturen gibt es kein Atom incoder vielleicht gar kein inc; Um eine atomare Inc auf MIPS auszuführen, müssen Sie eine Softwareschleife schreiben, die das llund sc: load-linked und store-bedingt verwendet. Load-linked liest das Wort und store-bedingt speichert den neuen Wert, wenn sich das Wort nicht geändert hat oder wenn es fehlschlägt (was erkannt wird und einen erneuten Versuch verursacht).

i++ beinhaltet zwei Operationen:

1. Lesen Sie den aktuellen Wert von i
2. Erhöhen Sie den Wert und weisen Sie ihn zu i

Wenn zwei Threads i++gleichzeitig dieselbe Variable ausführen , erhalten beide möglicherweise denselben aktuellen Wert von iund erhöhen und setzen ihn dann auf i+1, sodass Sie anstelle von zwei eine einzelne Inkrementierung erhalten.

Beispiel:

int i = 5;
Thread 1 : i++;
           // reads value 5
Thread 2 : i++;
           // reads value 5
Thread 1 : // increments i to 6
Thread 2 : // increments i to 6
           // i == 6 instead of 7

Das Wichtigste ist die JLS (Java Language Specification) und nicht, wie verschiedene Implementierungen der JVM eine bestimmte Funktion der Sprache implementiert haben oder nicht. Das JLS definiert den ++ Postfix-Operator in Abschnitt 15.14.2, der ua besagt, dass "der Wert 1 zum Wert der Variablen addiert und die Summe wieder in der Variablen gespeichert wird". Nirgends wird Multithreading oder Atomizität erwähnt oder angedeutet. Für diese bietet das JLS flüchtige und synchronisierte . Zusätzlich gibt es das Paket java.util.concurrent.atomic (siehe http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/package-summary.html ).

Warum ist i ++ in Java nicht atomar?

Teilen wir die Inkrementoperation in mehrere Anweisungen auf:

Thread 1 & 2:

1. Wert der Summe aus dem Speicher abrufen
2. Addiere 1 zum Wert
3. Schreiben Sie zurück in den Speicher

Wenn es keine Synchronisation gibt, nehmen wir an, Thread 1 hat den Wert 3 gelesen und auf 4 erhöht, ihn aber nicht zurückgeschrieben. Zu diesem Zeitpunkt erfolgt der Kontextwechsel. Thread zwei liest den Wert 3, erhöht ihn und der Kontextwechsel erfolgt. Obwohl beide Threads den Gesamtwert erhöht haben, ist es immer noch eine 4-Race-Bedingung.

i++ ist eine Aussage, die einfach 3 Operationen beinhaltet:

1. Aktuellen Wert lesen
2. Schreibe einen neuen Wert
3. Neuen Wert speichern

Diese drei Operationen sollen nicht in einem einzigen Schritt ausgeführt werden oder sind mit anderen Worten i++keine zusammengesetzte Operation. Infolgedessen können alle möglichen Probleme auftreten, wenn mehr als ein Thread an einer einzelnen, aber nicht zusammengesetzten Operation beteiligt ist.

Stellen Sie sich das folgende Szenario vor:

Zeit 1 :

Thread A fetches i
Thread B fetches i

Zeit 2 :

Thread A overwrites i with a new value say -foo-
Thread B overwrites i with a new value say -bar-
Thread B stores -bar- in i

// At this time thread B seems to be more 'active'. Not only does it overwrite 
// its local copy of i but also makes it in time to store -bar- back to 
// 'main' memory (i)

Zeit 3 :

Thread A attempts to store -foo- in memory effectively overwriting the -bar- 
value (in i) which was just stored by thread B in Time 2.

Thread B has nothing to do here. Its work was done by Time 2. However it was 
all for nothing as -bar- was eventually overwritten by another thread.

Und da hast du es. Eine Rennbedingung.

Deshalb i++ist nicht atomar. Wenn es so wäre, wäre nichts davon passiert und jedes fetch-update-storewürde atomar passieren. Genau dafür AtomicIntegerist es gedacht und in Ihrem Fall würde es wahrscheinlich genau dazu passen.

PS

Ein ausgezeichnetes Buch, das all diese und noch einige weitere Themen behandelt: Java Concurrency in Practice

In der JVM umfasst ein Inkrement ein Lesen und ein Schreiben, ist also nicht atomar.

Wenn die Operation i++atomar wäre, hätten Sie nicht die Möglichkeit, den Wert daraus zu lesen. Dies ist genau das, was Sie verwenden möchten i++(anstatt zu verwenden ++i).

Schauen Sie sich zum Beispiel den folgenden Code an:

public static void main(final String[] args) {
    int i = 0;
    System.out.println(i++);
}

In diesem Fall erwarten wir folgende Ausgabe: 0 (weil wir ein Inkrement veröffentlichen, z. B. zuerst lesen, dann aktualisieren)

Dies ist einer der Gründe, warum die Operation nicht atomar sein kann, da Sie den Wert lesen müssen (und etwas damit tun müssen) und dann den Wert aktualisieren müssen.

Der andere wichtige Grund ist, dass das atomare Ausführen von etwas aufgrund des Sperren normalerweise mehr Zeit in Anspruch nimmt. Es wäre albern, wenn alle Operationen an Primitiven in den seltenen Fällen, in denen Menschen atomare Operationen durchführen möchten, etwas länger dauern würden. Deshalb haben sie der Sprache AtomicIntegerund andere Atomklassen hinzugefügt .

Es gibt zwei Schritte:

1. hol ich aus dem Speicher
2. setze i + 1 auf i

Es ist also keine atomare Operation. Wenn thread1 i ++ ausführt und thread2 i ++ ausführt, kann der Endwert von i i + 1 sein.

Parallelität (die ThreadKlasse und dergleichen) ist eine zusätzliche Funktion in Version 1.0 von Java .i++wurde zuvor in der Beta hinzugefügt, und als solche ist es immer noch mehr als wahrscheinlich in seiner (mehr oder weniger) ursprünglichen Implementierung.

Es ist Sache des Programmierers, Variablen zu synchronisieren. Lesen Sie dazu das Tutorial von Oracle .

Bearbeiten: Zur Verdeutlichung ist i ++ eine gut definierte Prozedur vor Java, und als solche haben die Entwickler von Java beschlossen, die ursprüngliche Funktionalität dieser Prozedur beizubehalten.

Der ++ - Operator wurde in B (1969) definiert, der nur ein bisschen älter ist als Java und Threading.