Bagaimana Anda menyinkronkan akses ke status bersama?

Question

Accepted Answer

**Sinkronisasi** mengkoordinasikan akses thread ke status mutable bersama sehingga operasi tidak saling mengganggu secara berbahaya, mencegah **race conditions**. Java menawarkan beberapa mekanisme, dari kata kunci `synchronized` bawaan hingga locks eksplisit dan atomic lock-free.

## synchronized — mutual exclusion (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` memastikan hanya satu thread yang mengeksekusi kode terlindungi pada satu waktu (mutual exclusion) dan memberikan **visibility** — perubahan oleh satu thread menjadi terlihat oleh thread lain (itu melintasi 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` menjamin bahwa read/write variabel terlihat di seluruh thread — tetapi **TIDAK** membuat operasi gabungan (seperti `count++`) atomic. Gunakan untuk flag sederhana, bukan untuk read-modify-write.

## Atomic classes — 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
```

Kelas Atomic menyediakan operasi thread-safe tanpa locks — sering lebih cepat daripada `synchronized` untuk counter/accumulator sederhana.

## Explicit Locks — kontrol lebih

```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` menawarkan fitur yang `synchronized` tidak miliki: `tryLock()` (non-blocking), timed waits, fairness, dan read-write separation.

## Bahaya yang harus dikelola

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

## Mengapa ini penting

Sinkronisasi sangat penting untuk kebenaran kapan pun multiple thread mengakses status mutable bersama — tanpanya, race conditions menghasilkan data yang korup dan kegagalan intermiten yang hampir tidak mungkin untuk debug.

Mengetahui alat dan jaminan presisi mereka sangat penting: `synchronized` (mutual exclusion + visibility), `volatile` (visibility saja — BUKAN atomicity, kesalahpahaman umum), atomic classes (lock-free untuk operasi sederhana), dan Locks eksplisit (kontrol advanced).

Sama pentingnya adalah pemahaman bahaya — **deadlock** dan over-synchronization yang merusak performa — dan disiplin untuk mensinkronkan secara minimal dan konsisten.

Ini adalah pengetahuan inti, berisiko tinggi untuk Java server-side bersamaan dan topik interview mendalam yang membedakan developer yang dapat menulis kode multithreaded yang benar.