
Mutex์ Semaphore, Condition Variable๋ ๋๊ธฐํ/๋์์ฑ ์ ์ด์์ ์์ฃผ ์ค์ํ ๊ฐ๋ ์ ๋๋ค. Mutex์ Semaphore๊ฐ ๋ง์น ๊ตํต ์ฒด์ฆ์ ๊ด๋ฆฌํ๋ ๊ฒฝ์ฐฐ๊ด์ด๋ ์ ํธ๋ฑ๊ณผ ๊ฐ๋ค๋ฉด, Condition Variable์ ์ ํธ๊ฐ ๋ฐ๋๊ธธ ๊ธฐ๋ค๋ฆฌ๋ ์ฐจ๋๋ค์ ์ ์ง์ ๊ฐ์ ์กด์ฌ์ ๋๋ค. Condition Variable์ ์ด๋ค ์กฐ๊ฑด์ด ๋ง์กฑ๋ ๋๊น์ง ์ค๋ ๋๊ฐ ๊ธฐ๋ค๋ฆฌ๊ฒ ํด์ฃผ๋ ๋๊ธฐํ ๋๊ตฌ์ด๊ธฐ์, ์ด๋ฅผ ๊ตํต ์ ํธ์ ๋น์ ํ๋ฉด, ์ฐจ๋ค์ด ์ ํธ๊ฐ ์ด๋ก๋ถ๋ก ๋ฐ๋๊ธฐ ์ ๊น์ง ์ ์ง์ ์์ ๊ธฐ๋ค๋ฆฌ๋ ์ํฉ์ด๋ ๋น์ทํ๊ฑฐ๋ ์.
Mutex (Mutual Exclusion)
Mutex๋ ํ๊ตญ์ด๋ก "์ํธ ๋ฐฐํ(๋ฐฐ์ )"๋ก ๋ฒ์ญ๋ฉ๋๋ค. ๊ทธ ์ด๋ฆ ๊ทธ๋๋ก ๊ณต์ ์์์ ๋ํด ์ค์ง ํ๋์ ์ค๋ ๋๋ง ์ ๊ทผํ๋๋ก ํ์ฉํ๋ ๋ฉ์ปค๋์ฆ์ ๋๋ค. ๋ง์น ํ์ฅ์ค ๋ฌธ์ ์๋ ์ ๊ธ์ฅ์น์ ๊ฐ์ต๋๋ค.
- ์ ๊ธ(Lock)๊ณผ ํด์ (Unlock): Mutex๋ ๋ฑ ๋ ๊ฐ์ง ์ํ๋ฅผ ๊ฐ์ง๋๋ค. '์ ๊ธ ์ํ'์ 'ํด์ ์ํ'. ์ด๋ค ์ค๋ ๋๊ฐ ๊ณต์ ์์์ ์ ๊ทผํ๊ธฐ ์ ์ Mutex๋ฅผ ์ ๊ทธ๋ ค๊ณ ์๋ํฉ๋๋ค. ๋ง์ฝ Mutex๊ฐ ์ ๊ฒจ ์์ง ์๋ค๋ฉด, ๊ทธ ์ค๋ ๋๋ Mutex๋ฅผ ์ ๊ทธ๊ณ ๊ณต์ ์์์ ์ ๊ทผํ ์ ์๊ฒ ๋ฉ๋๋ค. ์์ ์ ๋ง์น๋ฉด, ๊ทธ ์ค๋ ๋๋ ๋ฐ๋์ Mutex๋ฅผ ํด์ ํด์ผ ํฉ๋๋ค.
- ์์ ๊ถ(Ownership): ์ค์ํ ์ ์ Mutex๋ฅผ ์ ๊ทผ ์ค๋ ๋๋ง์ด ๊ทธ Mutex๋ฅผ ํด์ ํ ์ ์๋ค๋ ๊ฒ์ ๋๋ค. ๋ค๋ฅธ ์ค๋ ๋๋ ์ ๊ธด Mutex๋ฅผ ๊ฐ์ ๋ก ํ ์ ์์ด์. ๋ง์น ํ์ฅ์ค ํค๋ฅผ ๊ฐ์ง ์ฌ๋๋ง ๋ฌธ์ ์ด ์ ์๋ ๊ฒ๊ณผ ๊ฐ์ฃ .
- ์ฃผ ์ฌ์ฉ์ฒ: ํ๋์ ์ค๋ ๋๋ง ์ ๊ทผํด์ผ ํ๋ ์๊ณ ์์ญ(critical section)์ ๋ณดํธํ๋ ๋ฐ ์ฃผ๋ก ์ฌ์ฉ๋ฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๊ณต์ ๋ณ์๋ฅผ ์ ๋ฐ์ดํธํ๋ ์ฝ๋ ๋ธ๋ก์ด๋ ํ์ผ์ ๋ฐ์ดํฐ๋ฅผ ์ฐ๋ ์์ ๋ฑ์ด ์์ต๋๋ค.
Semaphore
Semaphore๋ Mutex๋ณด๋ค ์ข ๋ ์ผ๋ฐํ๋ ๊ฐ๋ ์ ๋๋ค (Semaphore๋ Mutex๊ฐ ๋ ์ ์์ง๋ง Mutex๋ Semaphore๊ฐ ๋ ์ ์์ต๋๋ค). ๊ณต์ ์์์ ์ ๊ทผํ ์ ์๋ ์ค๋ ๋์ ์๋ฅผ ์ ํํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ๋ง์น ์ฃผ์ฐจ์ฅ์ ๋น์๋ฆฌ๋ฅผ ์ธ๋ ์ ๊ดํ๊ณผ ๊ฐ์ ๊ฒ์ ๋๋ค.
- ์นด์ดํฐ(Counter): Semaphore๋ ์นด์ดํฐ๋ฅผ ๊ฐ์ง๋ฉฐ, ์ฌ๊ธฐ์๋ 0 ์ด์์ ์ ์๊ฐ ๋ค์ด๊ฐ๋๋ค. ํ์ฌ ์ ๊ทผ ๊ฐ๋ฅํ ์์์ ์๋ฅผ ๋ํ๋ ๋๋ค.
- wait (P ์ฐ์ฐ)๊ณผ signal (V ์ฐ์ฐ)
- wait (P ์ฐ์ฐ): ์ค๋ ๋๊ฐ ๊ณต์ ์์์ ์ ๊ทผํ๋ ค๊ณ ํ ๋, Semaphore์ ์นด์ดํฐ๋ฅผ 1 ๊ฐ์์ํต๋๋ค. ๋ง์ฝ ์นด์ดํฐ๊ฐ 0๋ณด๋ค ํฌ๋ฉด ์ฆ์ ์์์ ์ ๊ทผํ ์ ์์ต๋๋ค. ๋ง์ฝ ์นด์ดํฐ๊ฐ 0 ์ดํ๊ฐ ๋๋ฉด, ๊ทธ ์ค๋ ๋๋ ์์์ด availableํด์ง ๋๊น์ง ๋๊ธฐ ์ํ์ ๋ค์ด๊ฐ๋๋ค. ๋ง์น ์ฃผ์ฐจ์ฅ์ ์๋ฆฌ๊ฐ ์์ผ๋ฉด ๊ธฐ๋ค๋ฆฌ๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค.
- signal (V ์ฐ์ฐ): ์ค๋ ๋๊ฐ ๊ณต์ ์์ ์ฌ์ฉ์ ๋ง์น๋ฉด, Semaphore์ ์นด์ดํฐ๋ฅผ 1 ์ฆ๊ฐ์ํต๋๋ค. ๋๊ธฐ ์ค์ธ ์ค๋ ๋๊ฐ ์๋ค๋ฉด, ๊ทธ ์ค ํ๋๊ฐ ๊นจ์ด๋ ์์์ ์ ๊ทผํ ์ ์๊ฒ ๋ฉ๋๋ค. ๋ง์น ์ฐจ๊ฐ ์ฃผ์ฐจ์ฅ์์ ๋๊ฐ๋ฉด ๋ค๋ฅธ ์ฐจ๊ฐ ๋ค์ด์ฌ ์ ์๊ฒ ๋๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค.
- ์ข
๋ฅ
- Binary Semaphore: ์นด์ดํฐ๊ฐ 0 / 1๋ง ๊ฐ์ง ์ ์๋ Semaphore์ ๋๋ค. ์ฌ์ค์ Mutex์ ์ ์ฌํ๊ฒ ๋์ํฉ๋๋ค. ์๋ ๋ ์์ธํ๊ฒ ์์ ๋ฉ๋๋ค.
- Counting Semaphore: ์นด์ดํฐ๊ฐ 0 ์ด์์ ์ ์ ๊ฐ์ ๊ฐ์ง ์ ์๋ Semaphore์ ๋๋ค. ํน์ ๊ฐ์์ ์์์ ๋ํ ์ ๊ทผ์ ์ ์ดํ๋ ๋ฐ ์ ์ฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๋์์ ์ ์ ๊ฐ๋ฅํ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์ฐ๊ฒฐ ์๋ฅผ ์ ํํ๋ ๋ฐ ์ฌ์ฉํ ์ ์์ต๋๋ค.
Mutex | Semaphore | |
๋ชฉ์ | ์ํธ ๋ฐฐ์ (ํ๋์ ์ค๋ ๋๋ง ์ ๊ทผ) | ์์ ์ ๊ทผ ๊ฐ๋ฅํ ์ค๋ ๋ ์ ์ ํ |
์ํ | ์ ๊น(Locked) / ํด์ (Unlocked) | 0 ์ด์์ ์ ์ ๊ฐ (์นด์ดํฐ) |
์์ ๊ถ | ์ ๊ทผ ์ค๋ ๋๋ง ํด์ ๊ฐ๋ฅ | ์์ ๊ถ ๊ฐ๋ ์์ |
์ฌ์ฉ ์ฌ๋ก | ์๊ณ ์์ญ ๋ณดํธ, ๋จ์ผ ์์ ์ ๊ทผ ์ ์ด | ์ ํ๋ ๊ฐ์์ ์์ ์ ๊ทผ ์ ์ด, ์ค๋ ๋ ๋๊ธฐํ |
Condition Variable
Pintos์์๋ Condition Variable (์ดํ ์ปจ๋์ ๋ณ์)๋ฅผ ๋ค๋ฃน๋๋ค. ์ปจ๋์ ๋ณ์๋, ์ค๋ ๋๋ค์ด ํน์ ์กฐ๊ฑด์ด ๋ง์กฑ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๊ฑฐ๋, ์กฐ๊ฑด์ด ๋ง์กฑ๋์์์ ์๋ฆฌ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋๊ธฐํ ๋๊ตฌ์ ๋๋ค. ๋ง์น ์๋น์์ ์์์ด ๋์ค๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ์๋๊ณผ ์์์ด ์์ฑ๋๋ฉด ์๋์ ํธ์ถํ๋ ์ง์๊ณผ ๊ฐ๋ค๊ณ ์๊ฐํ์๋ฉด ๋ฉ๋๋ค.
์ปจ๋์ ๋ณ์ ์์ฒด๋ ํน์ ์กฐ๊ฑด๊ณผ ์ฐ๊ฒฐ๋์ด ์์ต๋๋ค. ์ค๋ ๋๋ ์ด ์กฐ๊ฑด์ด ์ฐธ์ด ๋๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆด ์ ์๊ณ , ๋ค๋ฅธ ์ค๋ ๋๋ ์ด ์กฐ๊ฑด์ ์ฐธ์ผ๋ก ๋ง๋ ํ ๊ธฐ๋ค๋ฆฌ๋ ์ค๋ ๋๋ค์๊ฒ ์๋ฆผ์ ๋ณด๋ผ ์ ์์ต๋๋ค.
์ปจ๋์ ๋ณ์๋ ์ผ๋ฐ์ ์ผ๋ก mutex์ ํจ๊ป ์ฌ์ฉ๋๋ค๋ ์ ์ด ์ค์ํฉ๋๋ค. Mutex๋ ๊ณต์ ๋ณ์๋ฅผ ๋ณดํธํ๋ ์ญํ ์ ํ๊ณ , ์ปจ๋์ ๋ณ์์ ๊ทธ ๊ณต์ ๋ณ์์ ์ํ(ํน์ ์กฐ๊ฑด)์ ๋ฐ๋ผ ์ค๋ ๋๋ค์ ๋๊ธฐ์ํค๊ฑฐ๋ ๊นจ์ฐ๋ ์ญํ ์ ํฉ๋๋ค.
์ปจ๋์ ๋ณ์๊ฐ ์ ๊ณตํ๋ ์ฃผ์ ์ฐ์ฐ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- wait(condition, mutex): ์ด ํจ์๋ฅผ ํธ์ถํ ์ค๋ ๋๋ mutex๋ฅผ ํด์ ํ๊ณ , condition์ด ๋ง์กฑ๋ ๋๊น์ง ์ ์ ์ ๋ญ๋๋ค (๋๊ธฐ ํ์ ๋ค์ด๊ฐ๋๋ค). ๋์ค์ ๋ค๋ฅธ ์ค๋ ๋๊ฐ ์ด ์กฐ๊ฑด์ ๋ง์กฑ์ํค๊ณ signal ๋๋ broadcast๋ฅผ ํธ์ถํ๋ฉด, ์ด ์ค๋ ๋๋ ๊นจ์ด๋ ๋ค์ mutex๋ฅผ ํ๋ํ๋ ค๊ณ ์๋ํฉ๋๋ค. wait ํจ์๋ ๋ฐ๋์ mutex๊ฐ ์ ๊ธด ์ํ์์ ํธ์ถ๋์ด์ผ ํ๋ฉฐ, ๊นจ์ด๋ ํ์๋ ๋ค์ mutex๋ฅผ ํ๋ํด์ผ ํฉ๋๋ค.
- signal(condition): ์ด ํจ์๋ฅผ ํธ์ถํ๋ฉด, condition์ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋ ํ๋์ ์ค๋ ๋๋ฅผ ๊นจ์๋๋ค. ์ด๋ค ์ค๋ ๋๊ฐ ๊นจ์ด๋ ์ง๋ ์ค์ผ์ค๋ฌ์ ๋ฐ๋ผ ๋ค๋ฆ ๋๋ค. ๊นจ์ด๋ ์ค๋ ๋๋ ๋ค์ mutex๋ฅผ ํ๋ํ๋ ค๊ณ ๊ฒฝ์ํฉ๋๋ค.
- broadcast(condition): ์ด ํจ์๋ฅผ ํธ์ถํ๋ฉด, condition์ ๊ธฐ๋ค๋ฆฌ๊ณ ์๋ ๋ชจ๋ ์ค๋ ๋๋ฅผ ๊นจ์๋๋ค. ๊นจ์ด๋ ๋ชจ๋ ์ค๋ ๋๋ ๋ค์ mutex๋ฅผ ํ๋ํ๋ ค๊ณ ๊ฒฝ์ํฉ๋๋ค.
์ฐธ๊ณ ๋ก, Pintos์ ์ฐ์ ์์ ์ปจ๋์ ๋ณ์ ๊ด๋ จ ํ ์คํธ(priority-condvar)์์๋ semaphore๋ฅผ ํ์ธํ๋๋ฐ, ์ด์ชฝ์ mutex๋ฅผ ์ ์๋๋ค. ๋์ ์์ฒด์ ์ธ struct lock + struct condition ๊ตฌํ์ฒด๋ฅผ ์กฐํฉํ struct semaphore๋ฅผ ์ฌ์ฉํฉ๋๋ค.
์ฝ๋ ์์
์ค๋ช ๋ง์ผ๋ก๋ ์ ์ ์๋ฟ์ง์? ์๋๋ ์ ํ์ ์ธ ์์ฐ์-์๋น์ ํจํด ์์๋ก. ์์ฐ์๊ฐ ๋ฐ์ดํฐ๋ฅผ ๋ง๋ค์ด๋๋ฉด ์๋น์๊ฐ ๊ทธ๊ฑธ ๊ฐ์ ธ๊ฐ๋ ๊ตฌ์กฐ์ด๋ฉฐ, ์๋น์๋ ์ปจ๋์ ๋ณ์๋ก ์ ํธ๊ฐ ์ฌ ๋๊น์ง ๊ธฐ๋ค๋ ธ๋ค๊ฐ ๋ฐ์ดํฐ๊ฐ ์ค๋น๋๋ฉด ๊นจ์ด๋ฉ๋๋ค.
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <unistd.h>
int buffer = 0; // ๊ณต์ ์์
int data_ready = 0;
/* POSIX ์ค๋ ๋ ๋๊ธฐํ ํด */
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
void* producer(void* arg) {
sleep(1); // ์์ฐ์ด ๋ฆ๊ฒ ์ผ์ด๋๋ ์ํฉ์ ์๋ฎฌ๋ ์ด์
pthread_mutex_lock(&mutex);
buffer = 42; // ๋ฐ์ดํฐ ์์ฑ
data_ready = 1;
printf("Producer: ๋ฐ์ดํฐ ์์ฑ ์๋ฃ!\n");
pthread_cond_signal(&cond); // ์๊ฐ ์ปจ๋์
๋ณ์. ์๋น์์๊ฒ ์ ํธ๋ฅผ ๋ณด๋.
pthread_mutex_unlock(&mutex);
return NULL;
}
void* consumer(void* arg) {
pthread_mutex_lock(&mutex);
while (data_ready == 0) {
printf("Consumer: ๋ฐ์ดํฐ ์์ฑ์ ๊ธฐ๋ค๋ฆฌ๋ ์ค...\n");
pthread_cond_wait(&cond, &mutex); // ์กฐ๊ฑด์ด ๋ง์กฑ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆผ
}
printf("Consumer: ๋ฐ์ดํฐ ํ๋! %d\n", buffer);
pthread_mutex_unlock(&mutex);
return NULL;
}
void main() {
pthread_t t1, t2;
pthread_create(&t1, NULL, consumer, NULL);
pthread_create(&t2, NULL, producer, NULL);
pthread_join(t1, NULL);
pthread_join(t2, NULL);
pthread_mutex_destroy(&mutex);
pthread_cond_destroy(&cond);
}
์ฌ๊ธฐ์ pthread_cond_t cond;๊ฐ ๋ฐ๋ก ์ปจ๋์ ๋ณ์์ ๋๋ค. pthread_cond_wait()์ pthread_cond_signal()์์ ์ฐ์ด๊ณ , ์ค๋ ๋ ๊ฐ์ "์กฐ๊ฑด์ด ๋ง์กฑ๋๋ค"๋ ์ ํธ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๋ฉ์ปค๋์ฆ์ ๋๋ค. ํํธ int data_ready;๋ ์ค๋ ๋๊ฐ ์ธ์ ๊น์ง ๊ธฐ๋ค๋ ค์ผ ํ๋์ง๋ฅผ ์ ์ฅํ๋ flag๋ก ๋ณผ ์ ์์ต๋๋ค.
์ปจ๋์ ๋ณ์ ์์ฒด๋ "์ ํธ๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ์๋จ"์ด์ง, ์กฐ๊ฑด์ ์ฐธ/๊ฑฐ์ง์ ์ ์ฅํ์ง ์์ต๋๋ค. ๊ทธ๋์ ์ค์ ์กฐ๊ฑด(๋ฐ์ดํฐ๊ฐ ์ค๋น๋๋์ง)์ ๋ํ๋ผ flag๊ฐ ๊ฐ์ด ๋ฐ๋ผ์ค๋ ๊ฒ์ ๋๋ค.
์ Mutex์ ํจ๊ป ์ฌ์ฉ๋ ๊น์?
์ปจ๋์ ๋ณ์๋ ๊ณต์ ๋ณ์์ ์ํ(์กฐ๊ฑด)๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋์ํฉ๋๋ค. ์ด ๊ณต์ ๋ณ์๋ฅผ ์ฌ๋ฌ ์ค๋ ๋๊ฐ ๋์์ ์ ๊ทผํ๋ฉด ๋ฐ์ดํฐ ๋ถ์ผ์น ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ์ปจ๋์ ๋ณ์์ ์ฌ์ฉํ๊ธฐ ์ ์ ๋ฐ๋์ Mutex๋ฅผ ํ๋ํ์ฌ ๊ณต์ ๋ณ์๋ฅผ ๋ณดํธํด์ผ ํฉ๋๋ค.
- ์ค๋ ๋๊ฐ ํน์ ์กฐ๊ฑด์ ํ์ธํ๊ธฐ ์ ์ Mutex๋ฅผ ์ ๊ธ๋๋ค.
- ์กฐ๊ฑด์ด ๋ง์กฑ๋์ง ์์ผ๋ฉด, ์ค๋ ๋๋ ์ปจ๋์ ๋ณ์์ wait ํจ์๋ฅผ ํธ์ถํ๋ฉด์ Mutex๋ฅผ ํด์ ํ๊ณ ์ ๋ญ๋๋ค.
- ๋ค๋ฅธ ์ค๋ ๋๊ฐ ์กฐ๊ฑด์ ๋ง์กฑ์ํค๋ ์์ ์ ์ํํ ํ, ์ปจ๋์ ๋ณ์์ signal ๋๋ broadcast ํจ์๋ฅผ ํธ์ถํ์ฌ ๋๊ธฐ ์ค์ธ ์ค๋ ๋๋ฅผ ๊นจ์๋๋ค. ์ด๋, ๊นจ์ด๋ ์ค๋ ๋๋ ๋ค์ Mutex๋ฅผ ํ๋ํ๋ ค๊ณ ์๋ํฉ๋๋ค.
- Mutex๋ฅผ ํ๋ํ ์ค๋ ๋๋ ๋ค์ ์กฐ๊ฑด์ ํ์ธํ๊ณ , ๋ง์กฑ๋๋ฉด ์์ ์ ์งํํฉ๋๋ค.
Binary Semaphore (์ด์ง ์ธ๋งํฌ์ด)
์ด์ง ์ธ๋งํฌ์ด๋ ์ธ๋งํฌ์ด์ ํน๋ณํ ํํ๋ก, ์นด์ดํฐ๊ฐ 0 / 1๋ง ๋๋ ์ธ๋งํฌ์ด์ ๋๋ค. ์ด์ง ์ธ๋งํฌ์ด๋ Mutex์ ๋งค์ฐ ์ ์ฌํ๊ฒ ๋์ํ๋ฉฐ, ์ํธ ๋ฐฐ์ ๋ฅผ ๊ตฌํํ๋ ๋ฐ ์ฌ์ฉ๋ ์ ์์ต๋๋ค.
- ์ด๊ธฐ ๊ฐ์ ๋ณดํต 1๋ก ์ค์ ๋ฉ๋๋ค.
- wait ์ฐ์ฐ์ ํธ์ถํ๋ฉด ์นด์ดํฐ๊ฐ 0์ด ๋๊ณ , ๋ค๋ฅธ ์ค๋ ๋๋ wait ์ฐ์ฐ์ ํตํด ์ ๊ทผ ๋ถ๊ฐ๋ฅํ๊ฒ ๋ฉ๋๋ค (์ ๊ธ ์ํ์ ์ ์ฌ).
- signal ์ฐ์ฐ์ ํธ์ถํ๋ฉด ์นด์ดํฐ๊ฐ 1์ด ๋์ด, ๋ค๋ฅธ ์ค๋ ๋๊ฐ ๋ค์ wait ์ฐ์ฐ์ ํตํด ์ ๊ทผ ๋ถ๊ฐ๋ฅํ๊ฒ ๋ฉ๋๋ค (ํด์ ์ํ์ ์ ์ฌ).
Mutex vs. Binary Semaphore
๋์ด ์ ์ฌํ๊ฒ ๋์ํ์ง๋ง ์ธ๋ถ์ ์ผ๋ก๋ ์๋์ ๊ฐ์ด ์ฐจ์ด๊ฐ ์์ต๋๋ค.
๋ฎคํ ์ค | ์ด์ง ์ธ๋งํฌ์ด | |
๊ธฐ๋ฐ ๋ฉ์ปค๋์ฆ | ์ ๊ธ ๋ฉ์ปค๋์ฆ | ์ ํธ ์ ๋ฌ ๋ฉ์ปค๋์ฆ |
๋ฝ ํด์ | ๋ฎคํ ์ค๋ฅผ ํ๋ํ ์ค๋ ๋๋ ์๊ณ ๊ตฌ์ญ์ ๋ฒ์ด๋ ๋๋ง ๋ฎคํ ์ค๋ฅผ ํด์ ํ ์ ์์ต๋๋ค. | ํ์ฌ ์ค๋ ๋๋ณด๋ค ์ฐ์ ์์๊ฐ ๋์ ์ค๋ ๋๋ ๋ฐ์ด๋๋ฆฌ ์ธ๋งํฌ์ด๋ฅผ ํด์ ํ๊ณ ์ ๊ธ์ ํ๋ํ ์ ์์ต๋๋ค. |
๊ฐ | ๋ฎคํ ์ค ๊ฐ์ ์ ๊ธ ๋๋ ์ ๊ธ ํด์ ์ ๋ง์ฐฌ๊ฐ์ง๋ก ์์ ๋ ์ ์์ต๋๋ค. | ์ธ๋งํฌ์ด ๊ฐ์ wait() ๋ฐ signal() ์์ ์ ๋ฐ๋ผ ๋ณ๊ฒฝ๋ฉ๋๋ค. |
๋์ ํ๋ | ํ ๋ฒ์ ํ๋์ ์ค๋ ๋๋ง ๋ฎคํ ์ค๋ฅผ ํ๋ํ ์ ์์ต๋๋ค. | ์ฌ๋ฌ ๊ฐ์ ์ค๋ ๋๊ฐ ๋์์ ์ด์ง ์ธ๋งํฌ์ด๋ฅผ ํ๋ํ ์ ์์ต๋๋ค. |
์์ ๊ถ | ๋ฎคํ ์ค์๋ ์์ ๊ถ์ด ์์ด, ์์ ์๋ง์ด ์ ๊ธ์ ํด์ ํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ค. | ์ด์ง ์ธ๋งํฌ์ด์๋ ์์ ๊ถ์ด ์์ต๋๋ค. |
์ค๋ฒํค๋ | ์ด์ง ์ธ๋งํฌ์ด๋ณด๋ค ๋๋ฆฐ ์ด์ ๋ ์ ๊ธ์ ํ๋ํ ์ค๋ ๋๋ง ์ ๊ธ์ ํด์ ํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋๋ค. | ๋ค๋ฅธ ์ค๋ ๋/ํ๋ก์ธ์ค๊ฐ ๋ฐ์ด๋๋ฆฌ ์ธ๋งํฌ์ด๋ฅผ ์ ๊ธ ํด์ ํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ฎคํ ์ค๋ณด๋ค ๋น ๋ฆ ๋๋ค. |
์ธ์คํด์ค ์ | ๋ฆฌ์์ค์ ๋ํ ๋จ์ผ ์ธ์คํด์ค ์ ๊ทผ์๋ ๋ฎคํ ์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ์ข์ต๋๋ค. | ๋ฆฌ์์ค์ ๋ํ ์ธ์คํด์ค ์๊ฐ ๋ง์ ๊ฒฝ์ฐ ์ด์ง ์ธ๋งํฌ์ด๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ์ข์ต๋๋ค. |
ํ์ฉ ์ฌ๋ก | ๋ฐ์ดํฐ์ ์ผ๊ด์ฑ์ ์ ์ง | ๋ ์ผ๋ฐ์ ์ธ ๋๊ธฐํ ๋ฐ ์ค๋ ๋๊ฐ ํต์ |
์ถ์ฒ: https://www.geeksforgeeks.org/difference-between-binary-semaphore-and-mutex/
๊ฒฐ๊ตญ ๋์ ๋ฉ์ปค๋์ฆ, ์ฌ์ฉ๋ฒ, ์์ ๊ถ, ๋์ ๋ฐฉ์์ด ๋ค ๋ค๋ฅด๋ค๋ ๊ฒ์ ์ ์ ์์ต๋๋ค.
์ถ๊ฐ: ์ปจ๋์ ๋ณ์๋ฅผ ์๊ธฐํ ๋ ์ด์ง ์ธ๋งํฌ์ด๊ฐ ๊ฐ์ด ๋ฑ์ฅํ๋ ์ด์
๋ธ๋ก๊ทธ๋ฅผ ์ฐพ์๋ณด๋ค ๋ณด๋ฉด ์ปจ๋์ ๋ณ์๋ฅผ ์ค๋ช ํ๋ฉด์ ์ด์ง ์ธ๋งํฌ์ด๋ฅผ ๊ฐ์ด ์ด์ผ๊ธฐํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ์ปจ๋์ ๋ณ์๋ ๋ก์ฐ๋ ๋ฒจ ๋๊ธฐํ ๋ฉ์ปค๋์ฆ์ด๊ธฐ์, ๋๋ก๋ ์ด์ง ์ธ๋งํฌ์ด๋ฅผ ์ด์ฉํ์ฌ ์ปจ๋์ ๋ณ์์ ๊ธฐ๋ณธ์ ์ธ ๋์ ๋ฐฉ์์ ์ค๋ช ํ๊ฑฐ๋, ์ปจ๋์ ๋ณ์๋ฅผ ์ง์ ๊ตฌํํ๋ ๋ฐฉ์์ ์ค๋ช ํ๋ ๋ฐ ์ฐ์ ๋๋ค. ์๋ฅผ ๋ค์ด, wait ์ฐ์ฐ์ ๋ด๋ถ์ ์ผ๋ก ์ค๋ ๋๋ฅผ ๋ธ๋ก์ํค๊ณ , signal ์ฐ์ฐ์ ๋ธ๋ก๋ ์ค๋ ๋๋ฅผ ๊นจ์ฐ๋ ๋ฐฉ์์ผ๋ก ๊ตฌํ๋ ์ ์๋๋ฐ, ์ด๋ ์ด์ง ์ธ๋งํฌ์ด๊ฐ ์ด๋ฌํ ๋ฉ์ปค๋์ฆ์ ์ ์ดํ๋ ๋ฐ ํ์ฉ๋ ์ ์์ต๋๋ค.
์์ง ๋ง์์ผ ํ ๊ฒ์ ์ปจ๋์ ๋ณ์์ ์ด์ง ์ธ๋งํฌ์ด๋ ๊ฒฐ๊ตญ ๋ค๋ฅธ ๋ชฉ์ ์ ๊ฐ์ง ๋๊ตฌ๋ผ๋ ์ ์ ๋๋ค. ์ด์ง ์ธ๋งํฌ์ด๋ ์ฃผ๋ก ์ํธ ๋ฐฐ์ ๋ฅผ ๊ตฌํํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋ฐ๋ฉด, ์ปจ๋์ ๋ณ์๋ ํน์ ์กฐ๊ฑด์ ๋ฐ๋ฅธ ์ค๋ ๋๊ฐ ํจ์จ์ ์ธ ๋๊ธฐ ๋ฐ ์๋ฆผ ๋ฉ์ปค๋์ฆ์ ์ ๊ณตํฉ๋๋ค.
์๋ ํ์ธ์.
ํฌ์คํ ์ด ์ข์๋ค๋ฉด "์ข์์โค๏ธ" ๋๋ "๊ตฌ๋ ๐๐ป" ํด์ฃผ์ธ์!