Kako sinhronizujete pristup dijeljenom stanju?

Question

Accepted Answer

**Sinhronizacija** koordinira pristup niti dijeljenom mutable stanju tako da operacije se ne isprepliću opasno, sprječavajući **race conditions**. Java nudi nekoliko mehanizama, od ugrađene `synchronized` ključne riječi do eksplicitnih locks-a i lock-free atomica.

## synchronized — meðusobno isključivanje (intrinsic locks)

```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` osigurava da samo jedna nit izvršava zaštićeni kod odjednom (mutual exclusion) i pruža **vidljivost** — promjene jedne niti postaju vidljive drugima (prelazi memory barrier).

## volatile — vidljivost bez atomičnosti

```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` jamči da čitanja/pisanja varijable budu vidljiva između niti — ali **NE** čini složene operacije (kao `count++`) atomičnom. Koristite je za jednostave zastavice, ne za read-modify-write.

## Atomic klase — lock-free atomičnost

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

Atomic klase pružaju thread-safe operacije bez locks-a — često brže od `synchronized` za jednostavne brojače/akumulatore.

## Eksplicitni Locks — više kontrole

```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` nudi značajke koje `synchronized` nema: `tryLock()` (non-blocking), vremenske čekanja, pravednost, i read-write odvajanje.

## Opasnosti koje trebate upravljati

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

## Zašto je to važno

Sinhronizacija je bitna za ispravnost kad god više niti pristupa dijeljenom mutable stanju — bez nje, race conditions proizvode oštećene podatke i intermitentne, gotovo nemoguće za ispravljanje greške.

Znati alate i njihova precizna jamstva je kritično: `synchronized` (mutual exclusion + vidljivost), `volatile` (vidljivost samo — NE atomičnost, česta zablude), atomic klase (lock-free za jednostavne operacije) i eksplicitni Locks (napredna kontrola).

Jednako važno je razumijevanje opasnosti — **deadlock** i over-sinhronizacija koja šteti performansama — i disciplina da sinhronizujete minimalno i dosljedno.

Ovo je osnovna, visokorisična znanja za concurrent server-side Java i duboka interview tema koja razlikuje programere koji mogu pisati ispravan multithreaded kod.