你如何同步对共享状态的访问？

Question

你如何同步对共享状态的访问？

Accepted Answer

**Synchronization** 协调线程对共享可变状态的访问，防止操作危险地交错，从而防止 **race conditions**。Java 提供了多种机制，从内置的 `synchronized` 关键字到显式锁和无锁原子操作。

## synchronized — 互斥（内在锁）

```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` 确保在任何时刻只有一个线程执行受保护的代码（互斥），并提供 **visibility** — 一个线程的更改对其他线程可见（它跨越内存屏障）。

## volatile — 可见性但不原子性

```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` 保证变量的读/写在线程间可见 — 但 **不能** 使复合操作（如 `count++`）原子化。用它来处理简单标志，而不是读-修改-写操作。

## Atomic 类 — 无锁原子性

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

Atomic 类提供无锁的线程安全操作 — 对于简单计数器/累加器，通常比 `synchronized` 更快。

## 显式锁 — 更多控制

```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` 提供了 `synchronized` 所缺少的功能：`tryLock()`（非阻塞）、定时等待、公平性和读写分离。

## 要管理的危险

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

## 为什么这很重要

当多个线程访问共享可变状态时，同步对于正确性至关重要 — 没有它，竞态条件会产生数据损坏和间歇性、几乎无法调试的故障。

了解这些工具及其精确保证至关重要：`synchronized`（互斥 + 可见性）、`volatile`（仅可见性 — 非原子性，这是一个常见误解）、Atomic 类（简单操作的无锁）和显式锁（高级控制）。

同样重要的是理解危险 — **死锁** 和过度同步对性能的损害 — 以及最少且一致地进行同步的纪律。

这是并发服务器端 Java 的核心、高风险知识，也是一个深层的面试题目，用来区分能够编写正确多线程代码的开发人员。