공유 상태에 대한 접근을 어떻게 동기화합니까?

Question

IT Interview Practice · Accepted Answer

**동기화**는 연산이 위험하게 끼어들지 않도록 공유 가변 상태에 대한 thread들의 접근을 조율하여 **race condition**을 방지합니다. Java는 내장 `synchronized` 키워드부터 명시적 lock, 잠금 없는 atomic까지 여러 메커니즘을 제공합니다.

## synchronized — 상호 배제 (intrinsic lock)

```java
class BankAccount {
    private double balance;

// synchronized 메서드 — 객체의 lock 을 획득; 한 번에 하나의 thread 만
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;   // 보호됨 — 끼어듦 없음
        }
    }
    // synchronized 블록 — 더 세밀한 단위, 특정 객체에 lock
    public void deposit(double amount) {
        synchronized (this) {
            balance += amount;
        }
    }
}
```

`synchronized`는 한 번에 하나의 thread만 보호된 코드를 실행하도록 보장하고(상호 배제), **가시성**을 제공합니다 — 한 thread의 변경이 다른 thread에 보이게 됩니다(메모리 배리어를 넘어감).

## volatile — 원자성 없는 가시성

```java
private volatile boolean running = true;   // thread 간 가시성을 보장

public void stop() { running = false; }     // 다른 thread 가 변경을 즉시 봄
public void run() { while (running) { ... } } // volatile 없으면 false 를 못 볼 수도
```

`volatile`은 변수의 읽기/쓰기가 thread 간에 보이는 것을 보장합니다 — 하지만 복합 연산(`count++` 같은)을 원자적으로 만들지는 **않습니다**. 읽기-수정-쓰기가 아니라 단순 플래그에 사용하십시오.

## atomic 클래스 — 잠금 없는 원자성

```java
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();        // 잠금 없는 원자적 ++ (CPU CAS 명령어 사용)
counter.compareAndSet(5, 10);     // 원자적 조건부 갱신
```

atomic 클래스는 lock 없이 스레드 안전한 연산을 제공합니다 — 단순 카운터/누적기에는 종종 `synchronized`보다 빠릅니다.

## 명시적 Lock — 더 많은 제어

```java
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // 임계 영역
} finally {
    lock.unlock();   // 항상 finally 에서 unlock
}
// ReadWriteLock 은 많은 동시 reader 를 허용하되 writer 는 배타적
```

`ReentrantLock`은 `synchronized`에 없는 기능을 제공합니다: `tryLock()`(논블로킹), 시간 제한 대기, 공정성, 읽기-쓰기 분리.

## 관리해야 할 위험

```text
⚠️ Deadlock — 두 thread 가 서로 상대가 필요한 lock 을 잡음 → 둘 다 영원히 멈춤
   (항상 일관된 순서로 lock 을 획득하여 회피)
⚠️ 성능 — 과도한 동기화는 모든 것을 직렬화하여 동시성을 죽임
   (가장 작은 필요한 영역만 동기화)
⚠️ unlock 을 잊음 (명시적 Lock 사용 시) → try/finally 사용
```

## 왜 중요한가

동기화는 여러 thread가 공유 가변 상태에 접근할 때마다 정확성을 위해 필수적입니다 — 동기화 없이는 race condition이 손상된 데이터와 간헐적이고 거의 디버깅이 불가능한 실패를 일으킵니다.

도구와 그 정확한 보장을 아는 것이 중요합니다: `synchronized`(상호 배제 + 가시성), `volatile`(가시성만 — 원자성이 아님, 흔한 오해), atomic 클래스(단순 연산을 위한 잠금 없음), 명시적 Lock(고급 제어).

위험을 이해하는 것도 똑같이 중요합니다 — **deadlock**과 성능을 해치는 과도한 동기화 — 그리고 최소한으로 일관되게 동기화하는 규율입니다.

이는 동시 서버 측 Java를 위한 핵심적이고 위험이 큰 지식이며, 올바른 멀티스레드 코드를 작성할 수 있는 개발자를 구별하는 깊은 면접 주제입니다.

synchronized — 상호 배제 (intrinsic lock)

volatile — 원자성 없는 가시성

atomic 클래스 — 잠금 없는 원자성

명시적 Lock — 더 많은 제어

관리해야 할 위험

왜 중요한가

관련 질문