Làm thế nào để đồng bộ hóa truy cập vào shared state?

Question

Accepted Answer

**Synchronization** điều phối việc các thread truy cập vào shared mutable state sao cho các thao tác không xen kẽ nhau một cách nguy hiểm, qua đó ngăn chặn **race condition**. Java cung cấp nhiều cơ chế, từ keyword `synchronized` có sẵn cho tới các explicit lock và các atomic lock-free.

## synchronized — loại trừ lẫn nhau (intrinsic lock)

```java
class BankAccount {
    private double balance;

// synchronized method — chiếm lock của object; mỗi lần chỉ MỘT thread
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;   // được bảo vệ — không xen kẽ
        }
    }
    // synchronized block — chi tiết hơn, lock trên một object cụ thể
    public void deposit(double amount) {
        synchronized (this) {
            balance += amount;
        }
    }
}
```

`synchronized` đảm bảo mỗi lần chỉ một thread thực thi đoạn code được bảo vệ (mutual exclusion) và cung cấp **visibility** — thay đổi của một thread trở nên hiển thị với các thread khác (nó vượt qua memory barrier).

## volatile — visibility mà không có atomicity

```java
private volatile boolean running = true;   // đảm bảo VISIBILITY giữa các thread

public void stop() { running = false; }     // các thread khác thấy thay đổi ngay lập tức
public void run() { while (running) { ... } } // không có volatile, có thể không bao giờ thấy false
```

`volatile` đảm bảo việc đọc/ghi một biến hiển thị giữa các thread — nhưng **KHÔNG** làm cho các thao tác phức hợp (như `count++`) trở thành atomic. Hãy dùng nó cho các flag đơn giản, không phải cho read-modify-write.

## Atomic class — atomicity không cần lock

```java
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();        // ++ atomic không cần lock (dùng lệnh CAS của CPU)
counter.compareAndSet(5, 10);     // cập nhật có điều kiện một cách atomic
```

Các atomic class cung cấp các thao tác thread-safe mà không cần lock — thường nhanh hơn `synchronized` cho các counter/accumulator đơn giản.

## Explicit Lock — kiểm soát nhiều hơn

```java
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();   // LUÔN unlock trong finally
}
// ReadWriteLock cho phép nhiều reader đồng thời nhưng writer độc quyền
```

`ReentrantLock` cung cấp những tính năng mà `synchronized` không có: `tryLock()` (non-blocking), timed wait, fairness, và tách biệt read-write.

## Những hiểm họa cần quản lý

```text
⚠️ Deadlock — hai thread mỗi bên giữ một lock mà bên kia cần → cả hai kẹt mãi mãi
   (tránh bằng cách luôn chiếm lock theo một thứ tự nhất quán)
⚠️ Performance — over-synchronizing tuần tự hóa mọi thứ, giết chết concurrency
   (chỉ synchronize đoạn NHỎ NHẤT cần thiết)
⚠️ Quên unlock (với explicit Lock) → dùng try/finally
```

## Tại sao điều này quan trọng

Synchronization là thiết yếu cho tính đúng đắn mỗi khi nhiều thread truy cập shared mutable state — nếu không có nó, race condition tạo ra dữ liệu hỏng và những lỗi gián đoạn gần như không thể debug.

Việc nắm vững các công cụ và bảo đảm chính xác của chúng là rất quan trọng: `synchronized` (mutual exclusion + visibility), `volatile` (chỉ visibility — KHÔNG phải atomicity, một hiểu lầm phổ biến), atomic class (lock-free cho các thao tác đơn giản), và explicit Lock (kiểm soát nâng cao).

Cũng quan trọng không kém là hiểu được những hiểm họa — **deadlock** và over-synchronization làm tổn hại performance — và kỷ luật để synchronize tối thiểu và nhất quán.

Đây là kiến thức cốt lõi, có giá trị cao cho Java server-side đa luồng và là một chủ đề phỏng vấn sâu giúp phân biệt những developer có thể viết code đa luồng đúng đắn.