Piye carane sampeyan nyedhakake akses marang negara sing dilindonisasi?

Question

Accepted Answer

**Sinkronisasi** nglungake akses thread menyang negara sing bisa diganti sing dipratandani supaya operasi ora interleave kanthi mbebayani, nyegah **balapan kondisi**. Java nawakake sawetara mekanisme, saka keyword `synchronized` sing built-in nganti lock eksplisit lan atomik lock-free.

## synchronized — mutual exclusion (intrinsic lock)

```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` njamin mung siji thread sing ngleksekusi kode sing dilindungi ing wektu sing padha (mutual exclusion) lan nyediakake **visibility** — owah-owahan dening siji thread dadi katon marang liyane (iku ngubengi memory barrier).

## volatile — visibility tanpa 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` njamin yen maca/nulis variabel katon ing seluruh thread — nanging **ORA** nggawe operasi komposit (kaya `count++`) atomic. Gunakake kanggo banner simpel, ora kanggo read-modify-write.

## Atomic class — 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 class nyediakake operasi thread-safe tanpa lock — asring luwih cepet tinimbang `synchronized` kanggo counter/accumulator sing simpel.

## Explicit Lock — kontrol luwih

```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` nawakake fitur sing `synchronized` ora duwe: `tryLock()` (non-blocking), intip wektune, keadilan, lan pemisahan baca-tulis.

## Baya sing perlu ditangani

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

## Napa penting banget

Sinkronisasi penting kanggo kabenaran kapan-kapan ketoke margi akses thread multiplek negara sing bisa diganti — tanpa iku, balapan kondisi ngasilake data sing rusak lan gagal antara, meh-mustahil-kanggo-debug.

Ngenali alat lan jaminan presisine penting: `synchronized` (mutual exclusion + visibility), `volatile` (visibility mung — ORA atomicity, miskonsepsi umum), atomic class (lock-free kanggo operasi simpel), lan Explicit Lock (kontrol lanjut).

Sama pentinge ngerti baya — **deadlock** lan over-synchronization ndemek performa — lan disiplin kanggo nyedhakake minimal lan konsisten.

Iki minangka pengetahuan inti, tingkat bedil tinggi kanggo Java server-side concurrent lan topik wawancara jero sing mbedakake pengembang sing bisa nulis kode multithreaded sing bener.