V jakých případech byste měli používat atomic a v jakých synchronized?

synchronized se používá k ochraně bloku kódu nebo metody před současným přístupem více vláken ke sdíleným zdrojům, čímž zajišťuje jejich exkluzivní přístup.

Třídy atomic (například AtomicInteger, AtomicReference) poskytují atomické operace nad primitivními typy a odkazy, které nevyžadují explicitní zámky. Jsou založeny na mechanismu Compare-And-Swap (CAS) a jsou vhodné pro scénáře, kde je potřeba atomická operace nad jednou hodnotou bez úplného zámku.

Použijte atomic pro:

• Atomické operace nad jednotlivými proměnnými (inkrementace, dekrementace, aktualizace).
• Čítače a vlajky, ke kterým se přistupuje z více vláken.
• Scénáře, kde je výkon kritický a lze se vyhnout nákladům na zámky.

Použijte synchronized pro:

• Ochranu složitých datových struktur a objektů před současnými změnami.
• Koordinaci přístupu k více souvisejícím proměnným.
• Zamykání celých bloků kódu nebo metod.

Příklad synchronized:

class Counter {
    private int count = 0;

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

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

Příklad AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

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

    public void increment() {
        count.incrementAndGet(); // Atomické inkrementování
    }

    public int getCount() {
        return count.get(); // Atomické získání hodnoty
    }
}