Kaip sinchronizuoti prieigą prie bendrojo būsenos?

Question

Accepted Answer

**Sinchronizavimas** koordinuoja gijų prieigą prie bendros keičiamos būsenos, kad operacijos nepavojingai nepersidengė ir būtų išvengta **lenktynių sąlygų**. Java siūlo kelis mechanizmus, nuo integruoto `synchronized` raktažodžio iki aiškių užraktų ir be užrakto atomių.

## synchronized — savitarpio išskyrimas (vidinio užrakto)

```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` užtikrina, kad tik viena gija vykdo apsaugotą kodą vienu metu (savitarpio išskyrimas) ir suteikia **matomumą** — vienos gijos pakeitimai tampa matomi kitiems (jis kerta atminties barjerą).

## volatile — matomumas be automatiškumo

```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` garantuoja, kad kintamojo skaitymai/rašymai matomi visuose gijose — tačiau **NĖRA** daro sudėtinų operacijų (pvz., `count++`) atomines. Naudokite paprastiems žymekliam, o ne skaitymui-modifikavimui-rašymui.

## Atominės klasės — be užrakto automatiškumas

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

Atominės klasės suteikia gijų saugias operacijas be užraktų — dažnai greitesnės nei `synchronized` paprastiems skaitikliams/akumuliatoriams.

## Aiškūs užraktai — daugiau kontrolės

```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` siūlo funkcijas, kurias `synchronized` neturi: `tryLock()` (neblokuojimas), suplanuoti laukai, sąžiningumas ir skaitymo-rašymo atskyrimas.

## Pavojai, kuriuos reikia valdyti

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

## Kodėl tai svarbu

Sinchronizavimas yra būtinas teisingumui, kai kelios gijos pasiekia bendrą keičiamą būseną — jo neturėdamos, lenktynės sąlygos sukelia sugadintus duomenis ir tarpintinės, beveik neįmanomai derinamos klaidas.

Žinoti įrankius ir jų tikslias garantijas yra kritiškai svarbu: `synchronized` (savitarpio išskyrimas + matomumas), `volatile` (tik matomumas — NE automatiškumas, bendra nesupratimas), atominės klasės (be užrakto paprastiems veiksmams) ir aiškūs užraktai (išplėstinė kontrolė).

Tolygiai svarbu suprasti pavojus — **mirties akibrokštas** ir per didelis sinchronizavimas žalojantis veiklumą — ir discipliną sinchronizuoti minimaliai ir nuosekliai.

Tai yra pagrindinės, aukštos rizikos žinios lygiagrečiam serverio šono Java ir gilios interviu tema, kuri skiria kūrėjus, kurie gali parašyti teisingą daugiašalę kodą.