Kako sinkrionizirate dostop do skupnega stanja?

Question

Accepted Answer

**Sinhronizacija** koordinira dostop niti do skupnega spremenljivega stanja, tako da se operacije ne prepletajo nevarno in preprečuje **race conditions**. Java ponuja več mehanizmov, od vgrajenega ključnega besede `synchronized` do eksplicitnih zaklepov in lock-free atomike.

## synchronized — medsebojna izključevanja (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` zagotavlja, da samo ena nit izvaja zaščiteni kod naenkrat (medsebojna izključevanja) in zagotavlja **vidljivost** — spremembe ene niti postanejo vidne drugim (prečka memorijsko bariero).

## volatile — vidljivost brez atomike

```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` zagotavlja, da so branja/pisanja spremenljivke vidna preko niti — vendar **NE** naredi sestavljene operacije (kot `count++`) atomske. Uporabite ga za enostavne zastavice, ne za read-modify-write.

## Atomic classes — lock-free atomika

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

Atomic razredi zagotavljajo thread-safe operacije brez zaklepov — pogosto hitrejši od `synchronized` za enostavne števce/akumulatorje.

## Eksplicitni Locks — večji nadzor

```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` ponuja funkcionalnosti, ki jih `synchronized` nima: `tryLock()` (neblokiranje), časovni čakanja, pravičnost in ločitev branja-pisanja.

## Nevarnosti, ki jih je treba 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
```

## Zakaj je to pomembno

Sinhronizacija je nujna za korektnost, kadar je dostop več niti do skupnega spremenljivega stanja — brez nje race conditions povzročajo okvarjene podatke in občasne, skoraj nemogoče za debugiranje napake.

Poznavanja orodij in njihovih natančnih zagotovil so kritični: `synchronized` (medsebojna izključevanja + vidljivost), `volatile` (samo vidljivost — NE atomika, pogosta napačna predstava), atomic razredi (lock-free za enostavne operacije) in eksplicitni Locks (napredni nadzor).

Enako pomembno je razumevanje nevarnosti — **deadlock** in prezgodnja sinhronizacija, ki škodi zmogljivosti — in disciplina za minimalno in dosledne sinhronizacije.

To je temeljno, tvegano znanje za konkurentne strežniške Java aplikacije in poglobljena tema za pogovore, ki loči programerje, ki znajo napisati pravilno večnitni kod.