共有状態へのアクセスをどのように同期しますか？

Question

Accepted Answer

**同期**は、スレッドが共有可変状態にアクセスするのを調整し、操作が危険に交錯しないようにして、**競合状態**を防ぎます。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`は、保護されたコードを一度に1つのスレッドだけが実行することを保証し（相互排斥）、**可視性**を提供します — 1つのスレッドによる変更は他のスレッドに見えるようになります（メモリバリアを横切ります）。

## 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++`のような複合操作を原子的にするわけではありません。単純なフラグに使用し、read-modify-writeには使用しないでください。

## 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クラス（シンプルな操作に対するロックフリー）、および明示的ロック（高度な制御）。

同じくらい重要なのは、危険を理解することです — **デッドロック**とover-synchronizationがパフォーマンスを損なう — および最小かつ一貫して同期する規律です。

これは、並行サーバー側Javaの中核で高リスクの知識であり、正確なマルチスレッドコードを書くことができる開発者を区別する深いインタビュートピックです。