Bagaimana anda menyegerakkan akses ke keadaan bersama?

Question

IT Interview Practice · Accepted Answer

**Segerak** menyelaras akses utas ke keadaan boleh ubah bersama supaya operasi tidak berselang seli dengan berbahaya, mencegah **keadaan perlumbaan**. Java menawarkan beberapa mekanisme, daripada kata kunci `synchronized` terbina hingga kunci eksplisit dan atomik bebas kunci.

## synchronized — pengecualian bersama (kunci intrinsik)

```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 utas melaksanakan kod yang dilindungi pada satu masa (pengecualian bersama) dan memberikan **keterlihatan** — perubahan oleh satu utas menjadi kelihatan kepada yang lain (ia melintasi halangan ingatan).

## volatile — keterlihatan tanpa ketamatoman

```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 bahawa bacaan/penulisan pembolehubah kelihatan merentasi utas — tetapi **TIDAK** membuat operasi komposit (seperti `count++`) atomik. Gunakannya untuk bendera mudah, bukan untuk baca-ubah-tulis.

## Kelas Atom — ketamatoman bebas kunci

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

Kelas atom menyediakan operasi selamat benang tanpa kunci — selalunya lebih cepat daripada `synchronized` untuk kaunter/akumulator mudah.

## Kunci Eksplisit — lebih banyak kawalan

```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 ciri yang `synchronized` tidak mempunyai: `tryLock()` (tanpa menyekat), menunggu masa, keadilan, dan pemisahan baca-tulis.

## Bahaya yang perlu diurus

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

Segerak adalah penting untuk ketepatan apabila berbilang utas mengakses keadaan boleh ubah bersama — tanpanya, keadaan perlumbaan menghasilkan data yang rosak dan kegagalan sesaat, hampir mustahil untuk didebug.

Mengetahui alat dan jaminan pastinya adalah penting: `synchronized` (pengecualian bersama + keterlihatan), `volatile` (keterlihatan sahaja — BUKAN ketamatoman, salah faham biasa), kelas atom (bebas kunci untuk operasi mudah), dan Kunci Eksplisit (kawalan lanjutan).

Sama pentingnya memahami bahaya — **kebuntuan** dan lebih segerak memudaratkan prestasi — dan disiplin untuk menyegerak secara minimum dan konsisten.

Ini adalah pengetahuan teras, berisiko tinggi untuk Java sisi pelayan serentak dan topik temuduga yang mendalam yang membezakan pemaju yang dapat menulis kod multibentuk yang betul.

synchronized — pengecualian bersama (kunci intrinsik)

volatile — keterlihatan tanpa ketamatoman

Kelas Atom — ketamatoman bebas kunci

Kunci Eksplisit — lebih banyak kawalan

Bahaya yang perlu diurus

Mengapa ia penting

Soalan berkaitan