리더-라이터 문제 — 동기화 문제의 고전적 해법

허용되는 조합:
Reader + Reader  → O (동시 읽기 가능)
Reader + Writer  → X (충돌)
Writer + Writer  → X (충돌)

// 공유 변수
int read_count = 0;        // 현재 읽는 중인 Reader 수
semaphore mutex = 1;        // read_count 보호
semaphore rw_mutex = 1;     // Writer 진입 제어

// Reader
void reader() {
    wait(mutex);            // read_count 수정 보호
    read_count++;
    if (read_count == 1)
        wait(rw_mutex);     // 첫 번째 Reader가 Writer를 차단
    signal(mutex);

    // === 읽기 수행 ===

    wait(mutex);
    read_count--;
    if (read_count == 0)
        signal(rw_mutex);   // 마지막 Reader가 Writer 허용
    signal(mutex);
}

// Writer
void writer() {
    wait(rw_mutex);         // 배타적 접근

    // === 쓰기 수행 ===

    signal(rw_mutex);
}

int read_count = 0, write_count = 0;
semaphore r_mutex = 1;       // read_count 보호
semaphore w_mutex = 1;       // write_count 보호
semaphore rw_mutex = 1;      // 읽기-쓰기 상호 배제
semaphore queue = 1;         // Reader 진입 제어

// Writer
void writer() {
    wait(w_mutex);
    write_count++;
    if (write_count == 1)
        wait(queue);         // 대기 중인 Writer가 있으면 새 Reader 차단
    signal(w_mutex);

    wait(rw_mutex);
    // === 쓰기 수행 ===
    signal(rw_mutex);

    wait(w_mutex);
    write_count--;
    if (write_count == 0)
        signal(queue);
    signal(w_mutex);
}

// Reader
void reader() {
    wait(queue);             // Writer가 대기 중이면 여기서 블록
    wait(r_mutex);
    read_count++;
    if (read_count == 1)
        wait(rw_mutex);
    signal(r_mutex);
    signal(queue);

    // === 읽기 수행 ===

    wait(r_mutex);
    read_count--;
    if (read_count == 0)
        signal(rw_mutex);
    signal(r_mutex);
}

#include <pthread.h>

pthread_rwlock_t rwlock;
pthread_rwlock_init(&rwlock, NULL);

// Reader
pthread_rwlock_rdlock(&rwlock);   // 읽기 잠금 (여러 Reader 동시 가능)
// 읽기 수행
pthread_rwlock_unlock(&rwlock);

// Writer
pthread_rwlock_wrlock(&rwlock);   // 쓰기 잠금 (배타적)
// 쓰기 수행
pthread_rwlock_unlock(&rwlock);

ReadWriteLock lock = new ReentrantReadWriteLock();

// Reader
lock.readLock().lock();
try {
    // 읽기 수행
} finally {
    lock.readLock().unlock();
}

// Writer
lock.writeLock().lock();
try {
    // 쓰기 수행
} finally {
    lock.writeLock().unlock();
}

// 공정 모드: 가장 오래 기다린 스레드가 우선
ReadWriteLock fairLock = new ReentrantReadWriteLock(true);