Cum sincronizezi accesul la starea comună?

Question

Accepted Answer

**Sincronizarea** coordonează accesul thread-urilor la starea comună mutabilă, astfel încât operațiile să nu se intercaleze în mod periculos, prevenind **condiții de cursă**. Java oferă mai mecanisme, de la cuvântul cheie `synchronized` încorporat, la lacăte explicite și atomici fără lacăte.

## synchronized — excludere mutuală (lacăte intrinseci)

```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` asigură că doar un thread execută codul protejat la un moment dat (excludere mutuală) și oferă **vizibilitate** — modificările unui thread devin vizibile pentru alții (traversează bariera memoriei).

## volatile — vizibilitate fără atomicitate

```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` garantează că citirile/scrierile unei variabile sunt vizibile între thread-uri — dar NU face operațiile compuse (cum ar fi `count++`) atomice. Folosește-o pentru semnale simple, nu pentru citire-modificare-scriere.

## Clase Atomic — atomicitate fără lacăte

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

Classele Atomic oferă operații thread-safe fără lacăte — adesea mai rapide decât `synchronized` pentru contoare/acumulatoare simple.

## Lacăte explicite — mai mult control

```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` oferă caracteristici pe care `synchronized` nu le are: `tryLock()` (nebloc), așteptări cu termen, corectitudine și separare citire-scriere.

## Pericolele pe care trebuie să le gestionezi

```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
```

## De ce are importanță

Sincronizarea este esențială pentru corectitudine ori de câte ori mai mulți thread-uri accesează starea comună mutabilă — fără ea, condițiile de cursă produc date corupte și eșecuri intermitente, aproape imposibil de depanat.

Cunoașterea instrumentelor și a garanțiilor lor precise este critică: `synchronized` (excludere mutuală + vizibilitate), `volatile` (doar vizibilitate — NU atomicitate, o neînțelegere comună), clase atomice (fără lacăte pentru operații simple) și Lacăte explicite (control avansat).

La fel de important este înțelegerea pericolelor — **impas** și supra-sincronizare care dăunează performanței — și disciplina de a sincroniza minimal și consistent.

Acesta este cunoștințe esențiale, cu mize mari, pentru Java server-side concurent și un subiect de interviu aprofundat care deosebește dezvoltatorii care pot scrie cod multithreaded corect.