Jak synchronizujete přístup ke sdílenému stavu?

Question

Accepted Answer

**Synchronizace** koordinuje přístup vláken ke sdílenému měnitelному stavu tak, aby se operace nebezpečně nepromíchávaly, čímž se zabraňuje **race conditions**. Java nabízí několik mechanismů, od vestavěného klíčového slova `synchronized` až po explicitní zámky a lock-free atomické operace.

## synchronized — vzájemné vyloučení (intrinsické zámky)

```java
class BankAccount {
    private double balance;

// synchronized method — acquires the object's lock; only ONE thread at a time
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;   // protected — no interleaving
        }
    }
    // synchronized block — finer-grained, lock on a specific object
    public void deposit(double amount) {
        synchronized (this) {
            balance += amount;
        }
    }
}
```

`synchronized` zajistí, že v daný čas může kód chráněný pouze jedno vlákno (vzájemné vyloučení) a poskytuje **viditelnost** — změny jednoho vlákna se stanou viditelnými ostatním (překračuje paměťovou bariéru).

## volatile — viditelnost bez atomicity

```java
private volatile boolean running = true;   // guarantees VISIBILITY across threads

public void stop() { running = false; }     // other threads see the change immediately
public void run() { while (running) { ... } } // without volatile, might never see false
```

`volatile` garantuje, že čtení/zápis proměnné jsou viditelné mezi vlákny — ale **NENÍ** složené operace (jako `count++`) atomické. Použijte to pro jednoduché příznaky, ne pro operace čtení-modifikace-zápis.

## Atomic classes — lock-free atomicity

```java
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();        // atomic ++ without locking (uses CPU CAS instructions)
counter.compareAndSet(5, 10);     // atomic conditional update
```

Atomic třídy poskytují thread-safe operace bez zámků — často rychlejší než `synchronized` pro jednoduché čítače/akumulátory.

## Explicitní Locks — větší kontrola

```java
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();   // ALWAYS unlock in finally
}
// ReadWriteLock allows many concurrent readers but exclusive writers
```

`ReentrantLock` nabízí funkce, které `synchronized` postrádá: `tryLock()` (neblokující), vypršení časolistu, spravedlnost a oddělení čtení-zápisu.

## Nebezpečí, která je třeba řídit

```text
⚠️ Deadlock — two threads each hold a lock the other needs → both stuck forever
   (avoid by always acquiring locks in a consistent order)
⚠️ Performance — over-synchronizing serializes everything, killing concurrency
   (synchronize the SMALLEST necessary section)
⚠️ Forgetting to unlock (with explicit Locks) → use try/finally
```

## Proč je to důležité

Synchronizace je nezbytná pro správnost, kdykoliv více vláken přistupuje ke sdílenému měnitelному stavu — bez ní race conditions způsobují poškozená data a přerušované, téměř nemožné debugovat selhání.

Znalost nástrojů a jejich přesných záruk je kritická: `synchronized` (vzájemné vyloučení + viditelnost), `volatile` (pouze viditelnost — NE atomicity, častý omyl), atomic třídy (lock-free pro jednoduché operace) a explicitní Locks (pokročilá kontrola).

Rovněž důležité je chápat nebezpečí — **deadlock** a přesynchronizování poškozující výkon — a disciplínu synchronizovat minimálně a konzistentně.

Toto je základní, vysoce rizikové znalosti pro paralelní serverový Java kód a hluboké interviewové téma, které rozlišuje vývojáře, kteří mohou psát správný multithreadový kód.