모니터와 고전적 동기화 문제

public class BoundedBuffer<T> {
    private final Object[] buffer;
    private int count = 0, in = 0, out = 0;

    public BoundedBuffer(int size) {
        buffer = new Object[size];
    }

    public synchronized void produce(T item) throws InterruptedException {
        while (count == buffer.length) {
            wait();  // 버퍼 가득 참 → 조건 변수에서 대기 (락 자동 반납)
        }
        buffer[in] = item;
        in = (in + 1) % buffer.length;
        count++;
        notifyAll();  // 대기 중인 소비자 깨우기
    }

    @SuppressWarnings("unchecked")
    public synchronized T consume() throws InterruptedException {
        while (count == 0) {
            wait();  // 버퍼 비어있음 → 조건 변수에서 대기
        }
        T item = (T) buffer[out];
        out = (out + 1) % buffer.length;
        count--;
        notifyAll();  // 대기 중인 생산자 깨우기
        return item;
    }
}

import threading

class BoundedBuffer:
    def __init__(self, size):
        self.buffer = []
        self.size = size
        self.condition = threading.Condition()

    def produce(self, item):
        with self.condition:  # 자동으로 락 획득
            while len(self.buffer) >= self.size:
                self.condition.wait()  # 락 반납 + 대기
            self.buffer.append(item)
            self.condition.notify_all()  # 대기자 깨우기

    def consume(self):
        with self.condition:
            while len(self.buffer) == 0:
                self.condition.wait()
            item = self.buffer.pop(0)
            self.condition.notify_all()
            return item

# 올바른 코드
while not condition_is_true():
    condition.wait()

# 위험한 코드 (절대 사용하지 말 것)
if not condition_is_true():
    condition.wait()
    # 깨어났을 때 조건이 여전히 거짓일 수 있음!

#include <stdio.h>
#include <pthread.h>

pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t data_ready = PTHREAD_COND_INITIALIZER;
int data_available = 0;

void *producer(void *arg) {
    pthread_mutex_lock(&mutex);
    data_available = 1;
    printf("데이터 준비 완료\n");
    pthread_cond_signal(&data_ready);  /* 대기 중인 소비자 하나 깨우기 */
    pthread_mutex_unlock(&mutex);
    return NULL;
}

void *consumer(void *arg) {
    pthread_mutex_lock(&mutex);
    while (!data_available) {  /* while, not if */
        pthread_cond_wait(&data_ready, &mutex);
        /* wait 중에는 mutex가 반납됨 */
        /* 깨어나면 mutex를 다시 잡은 상태로 리턴 */
    }
    printf("데이터 소비\n");
    data_available = 0;
    pthread_mutex_unlock(&mutex);
    return NULL;
}

import threading
import time
import random

class DiningTable:
    def __init__(self, n):
        self.n = n
        self.state = ["thinking"] * n  # thinking, hungry, eating
        self.condition = [threading.Condition() for _ in range(n)]
        self.lock = threading.Lock()

    def pickup(self, i):
        with self.lock:
            self.state[i] = "hungry"
            self._test(i)
        with self.condition[i]:
            while self.state[i] != "eating":
                self.condition[i].wait()

    def putdown(self, i):
        with self.lock:
            self.state[i] = "thinking"
            # 양옆 철학자가 먹을 수 있는지 확인
            self._test((i - 1) % self.n)
            self._test((i + 1) % self.n)

    def _test(self, i):
        left = (i - 1) % self.n
        right = (i + 1) % self.n
        if (self.state[i] == "hungry" and
            self.state[left] != "eating" and
            self.state[right] != "eating"):
            self.state[i] = "eating"
            with self.condition[i]:
                self.condition[i].notify()

def philosopher(table, i):
    for _ in range(3):
        print(f"철학자 {i} 생각 중...")
        time.sleep(random.uniform(0.1, 0.3))
        table.pickup(i)
        print(f"철학자 {i} 식사 중!")
        time.sleep(random.uniform(0.1, 0.2))
        table.putdown(i)

table = DiningTable(5)
threads = [threading.Thread(target=philosopher, args=(table, i)) for i in range(5)]
for t in threads: t.start()
for t in threads: t.join()