In welchen Fällen sollte man atomic und in welchen synchronized verwenden?

synchronized wird verwendet, um einen Codeblock oder eine Methode vor gleichzeitigem Zugriff mehrerer Threads auf gemeinsam genutzte Ressourcen zu schützen und so exklusiven Zugriff zu gewährleisten.

Die atomic-Klassen (z.B. AtomicInteger, AtomicReference) bieten atomare Operationen an primitiven Typen und Referenzen, die keine explizite Sperre erfordern. Sie basieren auf dem Compare-And-Swap (CAS)-Mechanismus und eignen sich für Szenarien, in denen eine atomare Operation an einem einzelnen Wert ohne vollständige Sperrung erforderlich ist.

Verwenden Sie atomic für:

• Atomare Operationen an einzelnen Variablen (Inkrementieren, Dekrementieren, Aktualisieren).
• Zähler und Flags, auf die von mehreren Threads zugegriffen wird.
• Szenarien, in denen die Leistung kritisch ist und Sperrkosten vermieden werden können.

Verwenden Sie synchronized für:

• Schutz komplexer Datenstrukturen und Objekte vor gleichzeitigen Änderungen.
• Koordination des Zugriffs auf mehrere zusammenhängende Variablen.
• Sperren ganzer Codeblöcke oder Methoden.

Beispiel für synchronized:

class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

Beispiel für AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

class AtomicCounter {
    private final AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // Atomare Inkrementierung
    }

    public int getCount() {
        return count.get(); // Atomare Wert-Erfassung
    }
}