세마포어

🔐 락과 조건변수보다 강력한 동기화 도구? 바로 세마포어!

멀티쓰레드 프로그래밍을 하다 보면 이런 상황을 자주 만나게 됩니다.

• 여러 개의 쓰레드가 하나의 자원을 동시에 사용하려 한다
• 어떤 쓰레드는 특정 조건이 만족될 때까지 기다려야 한다
• 누가 먼저 실행되었느냐에 따라 프로그램이 꼬일 수 있다

이럴 때 우리가 흔히 사용하는 도구가 락(mutex)과 조건 변수(condition variable)입니다.
하지만… 세마포어(semaphore) 하나면 이 둘의 역할을 전부 할 수 있다는 사실, 알고 계셨나요?

---

✅ 세마포어란?

세마포어는 '숫자 하나를 조작하면서 쓰레드 간 동기화를 하는 기법'입니다.
말 그대로 정수 하나를 갖고 wait/post 연산만으로 여러 쓰레드를 조율하는 거죠!

#include <semaphore.h>

sem_t s;
sem_init(&s, 0, 1); // 세마포어 초기값 1
sem_wait(&s);       // 자원 획득 시도 (잠그기)
sem_post(&s);       // 자원 반환 (풀기)

 

sem_wait(&s)

1. 세마포어 s의 값을 1 감소
2. 줄인 결과가 0 이상이면, 계속 진행합니다.
3. 음수면, 현재 쓰레드는 기다림(wait/block) 상태로 들어갑니다.

sem_post(&s)

1. 세마포어 s의 값을 1 증가
2. 이때 대기 중인 쓰레드가 있다면, 그 중 하나를 깨웁니다.

 

 

이걸 이용하면 락처럼도, 조건변수처럼도 사용할 수 있어요.

 

🤔 그럼 세마포어 값이 왜 음수가 될 수 있죠?

세마포어의 값은 대기 중인 쓰레드 수를 나타낼 수도 있기 때문입니다.
예를 들어:

• 초기값이 1인 이진 세마포어 (락 역할)
• 쓰레드 A가 sem_wait() → -1 → 값은 0
• 쓰레드 B가 sem_wait() → -1 → 값은 -1 → 쓰레드 B: 대기 상태

즉, 세마포어의 값이 0보다 작으면 그만큼의 쓰레드가 대기 중이라는 의미입니다.

 

---

🔁 이진 세마포어 = 락

세마포어를 1로 초기화하고 한 번에 하나의 쓰레드만 접근하게 하면 락처럼 사용할 수 있습니다.

sem_t mutex;
sem_init(&mutex, 0, 1);

sem_wait(&mutex); // 락 획득
// 임계 구역
sem_post(&mutex); // 락 해제

 

쓰레드 0: sem_wait()를 호출한다 -> 세마포어 값을 1 감소시켜 0으로 만든다

 

쓰레드 0: 락을 보유하고 있을 때

 

<상황>

쓰레드0이 sem_wait()를 호출 하여 임계 영역에 진입했지만 아직 sem_post()를 호출하지 않은 경우

쓰레드 1가 sem_wait()를 호출하여 임계 영역 진입을 시도하는 경우

 

쓰레드 1: 세마포어 값을 -1로 감소시키고 쓰레드1은 대기에 들어간다.

 

이진 세마포어 == lock 과 같네요

 

 

 

---

😴 조건 기다릴 때도 세마포어!

세마포어 초기값을 0으로 하면, 기본적으로 대기 상태입니다.
예를 들어, 부모 쓰레드가 자식 쓰레드의 종료를 기다리는 코드도 이렇게 만들 수 있어요

 

자식을 대기 중인 부모 : 초기값을 0으로 한다

sem_t done;
sem_init(&done, 0, 0); // 0으로 초기화

void* child(void*) {
  printf("child\n");
  sem_post(&done); // 자식의 동작이 끝나면 ->부모를 깨운다!
  return NULL;
}

int main() {
  printf("parent: begin\n");
  pthread_create(..., child, ...);// 자식 쓰레드 생성
  sem_wait(&done); // 자식 끝날 때까지 대기
  printf("parent: end\n");
}

 

 

상황1) 자식 프로세스 생성 후, 아직 자식 프로세스가 실행을 시작하지 않은 경우

자식이 sem_post()를 호출하기 전에

부모가 sem_wait()를 호출할 것이다.

부모 프로세스는 자식이 실행될 때까지 대기해야 한다.

부모가 실행되면 세마포어 값을 감소시키고 대기한다.

자식이 실행되ᨩ을 때 sem_post()를 호출하여 세마포어의 값을 0으로 증가시킨 후 부모를 깨운다

부모는 sem_wait()에서 리턴을 하여 프로그램을 종료.

 

상황2) 부모 프로세스가 sem_wait()를 호출하기 전에, 자식 프로세스의 실행이 종료된 경우

자식이 먼저 sem_post()를 호출하여 세마포어의 값을 0에서 1로 증가시킨다.

부모가 실행할 수 있는 상황이 되면 sem_wait() 를 호출한다.

세마포어 값이 1인 것을 발견할 것이다.

부모는 세마포어 값을 0으로 감소시키고 sem_wait()에서 대기 없이 리턴한다

---

🍞 생산자 / 소비자 문제? 세마포어로 완벽 해결!

유명한 생산자-소비자 문제도 세마포어로 멋지게 해결됩니다. 핵심은 두 가지 세마포어:

• empty → 빈 버퍼 공간 개수 (초기값: 버퍼 크기)
• full → 채워진 데이터 수 (초기값: 0)

생산자는 empty를 기다리고 full을 올림
소비자는 full을 기다리고 empty를 올림
여기에 mutex 세마포어를 더해 임계 구역 보호도 완벽!

 

---

MAX=1 일 때

 

 

 

MAX=10 일 때

생산자와 소비자 쓰레드들이 여러 개 있다고 하자. 

두 쓰레드가 put() 을 거의 동시에 호출하면 경쟁 조건이 발생한다

 

쓰레드1: 먼저 실행되어서 버퍼에 첫 공간에 값을 넣기 시작한다

쓰레드1: fill 카운터 변수가 1로 변경하기 전에 인터럽트가 걸렸다

 

쓰레드2: 버퍼의 첫 번째 공간에 데이터를 삽입 -> 쓰레드1이 기록한 이전의 값은 새로운 값으로 대체

 

---

경쟁 조건 해결 : 상호 배제 추가

🔐 왜 mutex가 필요할까?

버퍼에 값을 넣거나 꺼내는 put()과 get()은 공유 자원(버퍼)을 수정합니다.
→ 동시에 여러 쓰레드가 들어오면 데이터가 꼬일 수 있어요!

 

그래서 mutex 세마포어를 락처럼 사용해서,
한 번에 한 명만 버퍼를 건드리게 만드는 거예요.

이름	설명	초기값
empty	버퍼에 비어 있는 칸 수	MAX (버퍼 크기)
full	버퍼에 채워진 칸 수	0
mutex	🔐 공유 자원 접근을 1명만 허용하는 락	1 (이진 세마포어)

 

✅ 생산자 코드 요약

sem_wait(&empty);  // 버퍼 빈 칸 하나 줄이기 (없으면 대기)
sem_wait(&mutex);  // 락 잡기 (다른 애들 못 들어오게)
put(i);            // 버퍼에 데이터 넣기
sem_post(&mutex);  // 락 풀기
sem_post(&full);   // 채운 칸 수 증가 (소비자 깨우기)

 

✅ 소비자 코드 요약

sem_wait(&full);   // 채워진 칸이 없으면 기다림
sem_wait(&mutex);  // 락 잡기 (버퍼 건드릴 준비)
int tmp = get();   // 버퍼에서 데이터 꺼냄
sem_post(&mutex);  // 락 풀기
sem_post(&empty);  // 빈 칸 수 증가 (생산자 깨움)

 

✅ 핵심 요약

• empty, full: 생산자/소비자 간 타이밍 조절
• mutex: 버퍼 자체를 보호하는 락

이 세 가지 세마포어만 잘 조합하면, 안전한 동시 프로그래밍이 가능합니다!

---

📚 세마포어 vs 락+조건변수?

구분	세마포어	락 + 조건 변수
동기화 방식	정수 기반, wait/post	락 + 조건 대기 / 시그널
구현 난이도	단순하지만 직관적이지 않을 수 있음	더 명확한 구조화 가능
유연성	락도 되고, 조건 변수도 됨	역할 분리
대표 사용 예시	Reader-Writer 락, 철학자 문제	특정 조건 대기 상황

---

📚 Reader-Writer 락이란?

✔ 왜 필요할까?

• 어떤 데이터는 읽을 때는 충돌이 안 나지만,
• 쓸 때는 충돌이 나요!

예시: 도서관 책

• 여러 명이 동시에 책을 읽는 건 OK ✅
• 누군가 책에 낙서(쓰기)를 한다면? → 혼자만 해야 함 ❌

🧩 핵심 아이디어

• Reader(읽기): 여러 쓰레드가 동시에 읽어도 됨
• Writer(쓰기): 혼자만 써야 함. 읽기도 못 들어오게 해야 함

 

🔧 구조체 설명

typedef struct _rwlock_t {
    sem_t lock;         // readers 카운트를 보호하는 락
    sem_t writelock;    // 실제 쓰기 보호 락
    int readers;        // 현재 읽고 있는 reader 수
} rwlock_t;

 

• readers: 현재 읽고 있는 쓰레드 수
• lock: readers 값을 조작할 때 충돌 안 나게 보호
• writelock: 쓰기 쓰레드가 들어갈 때 사용하는 진짜 락

 

 

✅ 읽기 락 획득 (rwlock_acquire_readlock)

sem_wait(&rw->lock);         // readers 수 보호용 락
rw->readers++;
if (rw->readers == 1)
    sem_wait(&rw->writelock);  // 첫 번째 리더만 writelock 잠금
sem_post(&rw->lock);         // readers 수 조작 끝​

• 읽는 사람이 처음 한 명일 때만 writelock을 잡아요.
• 그 이후 리더들은 그냥 count만 늘리고 들어가요.
• 여러 리더가 동시에 읽을 수 있어요!

 

 

✅ 읽기 락 해제 (rwlock_release_readlock)

sem_wait(&rw->lock);
rw->readers--;
if (rw->readers == 0)
    sem_post(&rw->writelock);  // 마지막 리더가 나갈 때 writelock 해제
sem_post(&rw->lock);

 

• 마지막 읽는 사람이 나가면 writelock을 풀어줍니다.
• 이제 writer가 들어갈 수 있게 됩니다.

 

 

✅ 쓰기 락 획득 & 해제

sem_wait(&rw->writelock);   // 쓰려면 무조건 단독 진입!
...
sem_post(&rw->writelock);

 

• 쓰는 쓰레드는 writelock을 혼자 잡고 작업
• 읽는 사람 하나라도 있으면 못 들어감!

 

---

🧠 마무리: 세마포어는 동기화의 만능도구!

세마포어는 락도 되고, 조건 변수도 되고, 심지어 둘을 합친 것 이상의 강력하고 유연한 도구입니다.
단, 너무 자유롭기 때문에 잘못 쓰면 교착 상태(deadlock)나 기아(starvation)에 빠질 수 있으니 주의!

멀티쓰레드 환경을 설계할 때, 세마포어라는 도구를 잘 활용해 보세요.
정확하게만 쓰면, 복잡한 동기화 문제도 깔끔하게 해결할 수 있습니다! 💪

---

🍽️ 식사하는 철학자 문제란?

다섯 명의 철학자가 둥근 식탁에 앉아 있고, 철학자는 생각하거나 먹을 수 있어요.
식사를 하려면 왼쪽과 오른쪽의 포크 2개를 모두 집어야 해요.
포크는 철학자 사이에 하나씩 있어서 총 5개예요.

while (1) {
  think();     // 생각 중
  getforks();  // 양쪽 포크 잡기 (왼쪽, 오른쪽)
  eat();       // 식사
  putforks();  // 포크 내려놓기
}

 

 

이 간단한 설정에서 다음과 같은 병행 프로그래밍의 핵심 문제들이 등장합니다:

 

1. 🔒 교착 상태 (Deadlock)

모든 철학자가 동시에 왼쪽 포크를 집고,
오른쪽 포크를 기다리면?
→ 영원히 기다리게 됨. 프로그램 멈춤.

 

2. 🚫 기아 상태 (Starvation)

철학자 A는 계속 포크를 잡지 못하고 굶주림.
→ 어떤 쓰레드도 영원히 자원 못 받는 상황.

 

3. ⚖️ 병행성 (Concurrency)

• 가능한 많은 철학자가 동시에 밥 먹을 수 있어야 효율적.
• 단, 안전하게!

 

✅ 정리: 왜 이 문제가 나왔는가?

 

이유	설명
동기화의 3대 이슈 설명 가능	교착, 기아, 병행성
비유가 직관적임	철학자 = 쓰레드, 포크 = 공유 자원
면접과 시험 단골	깊이 있고, 짧은 코드로 구현 가능
세마포어, 뮤텍스 응용 문제로 적합	실제 동기화 기술을 넣어서 풀게 만듦

 

---

 

1️⃣ Lock과 Conditon Variable 대신에 세마포어를 사용하는 방법은 무엇인가?

• 세마포어 == Lock: 세마포어의 값이 1이면 뮤텍스(Lock)처럼 동작 (이진 세마포어).
• 세마포어 == Condtion Variable: 조건을 기다리는 대신, 세마포어의 값이 0이면 wait(), 값이 증가하면 signal()처럼 wake-up 효과 발생.
• 세마포어는 wait()/signal() 호출 시 어떤 쓰레드가 깨어날지 제어하기 어려움
• 조건 변수는 락과 정확하게 결합되어 있고 조건 불변식(predicate)을 체크 후 wait 하는 패턴을 강제할 수 있지만 세마포어는 그런 구조가 약합니다.
• 그래서 가능하지만 더 복잡해지고 유지보수가 어려움 → 일반적으로 락 + 조건 변수를 그대로 사용하는 것이 더 나은 설계입니다.

 

2️⃣ 세마포어의 정의는 무엇인가?

세마포어 (Semaphore):

• 정수값을 가지는 동기화 원시(primitive).
• 원자적 연산 제공:
  • wait() 또는 P() 또는 down() → 값 감소. 0보다 작아지면 블록(block).
  • signal() 또는 V() 또는 up() → 값 증가. 대기 중인 쓰레드 하나 깨움.

종류:

• Counting Semaphore: 0 이상 n까지 값 가능. 여러 리소스 접근 제어 가능.
• Binary Semaphore (이진 세마포어): 값이 0 또는 1 → 뮤텍스처럼 사용 가능.

 

3️⃣ 이진 세마포어는 무엇인가?

• 이진 세마포어 = 값이 0 또는 1 만 허용.
• 뮤텍스와 매우 유사:
  • 1일 때 → lock 가능
  • 0일 때 → lock된 상태 (wait 발생)
• 뮤텍스는 "소유자(owner)" 개념 존재.
• 세마포어는 그냥 일반적인 counter 기반 → 반드시 락 소유자가 unlock 해야 한다는 강제성 없음.

 

4️⃣ 락과 컨디션 변수를 사용하여 세마포어를 만드는 것이 가능한가?

• 세마포어의 내부 상태 count 변수를 락으로 보호.
• wait() → 락 획득 후 count--. count < 0 이면 컨디션 변수 wait().
• signal() → 락 획득 후 count++. count <= 0 이면 컨디션 변수 signal().

→ 즉, 락 + 컨디션 변수 조합으로 세마포어 구현 가능.

 

5️⃣ 그 반대로 세마포어를 사용하여 락과 조건 변수를 만드는 것이 가능한가?

락: 이진 세마포어(값이 1) 사용 → lock/unlock 가능.

컨디션 변수: 부분적으로 가능하지만 한계 존재.

• 컨디션 변수는 락과 함께 쓰이며 "조건"을 체크 후 기다리는 패턴이 중요.
• 세마포어는 wait() 시 조건 불변식(predicate check) 없이 블록되므로 명확한 의미론적 차이 존재.
• 구현은 가능하지만 조건 변수의 정확한 의미론(예: spurious wakeup 대응 등)을 충실하게 맞추기는 어려움.