์ฐ์ ๊ธฐ๋ก ๐ช
๋ฎคํ ์ค, ์ธ๋งํฌ์ด, ๋ชจ๋ํฐ ๋ณธ๋ฌธ
์์ ๊ธ์์ ํ๋ก์ธ์ค๋ ์ฐ๋ ๋๊ฐ ๋์์ ์๊ณ๊ตฌ์ญ ์ฝ๋๋ฅผ ์คํํ๋ฉด ๋ ์ด์ค ์ปจ๋์ ์ด ๋ฐ์ํ๋ค๊ณ ํ๋ค. ์ด๊ฒ์ ํด๊ฒฐํ๊ธฐ ์ํ ๋ฐฉ๋ฒ์ผ๋ก๋ ๋ฎคํ ์ค, ์ธ๋งํฌ์ด, ๋ชจ๋ํฐ ๋ฑ์ด ์๋ค. ์ด๋ค์ ๋ํด ํ๋ํ๋ ์์๋ณด๋๋ก ํ์.
๋ฎคํ ์ค(MUTEX, MUTual EXclusion)
๋ฎคํ ์ค๋ ์๊ณ๊ตฌ์ญ์ ์ ๊ทผํ๊ณ ์ ํ๋ค๋ฉด ๋ฝ(Lock)์ ํ๋ํด์ผ ํ๊ณ , ์์ ์ด ๋๋๋ฉด ๋ฝ์ ํด์ (Release)ํ๋๋ก ํจ์ผ๋ก์จ ๋์์ ์๊ณ๊ตฌ์ญ์ ์ ๊ทผํ์ง ๋ชปํ๊ฒ ํ๋ ๊ธฐ๋ฒ์ด๋ค.
์ฐธ๊ณ ๋ก ํ์ด์ฌ์ด๋ C/C++์ ๋ฎคํ ์ค ๋ฝ์ ์ง์ํ๊ณ , Java์ญ์ ๋ฝ์ ์ง์ํ๋ค. C++์์ ๋ฎคํ ์ค ๋ฝ์ ํ์ฉํ๋ ์์ ๋ ์๋์ ๊ฐ๋ค.
#include <iostream>
#include <thread>
#include <mutex>
using namespace std;
int counter = 0;
mutex m; //๋ฎคํ
์ค ์ ์ธ
void increment() {
for (int i = 0; i < 10000; ++i) {
m.lock(); //๊ณต์ ์์ ์ ๊ทผ ์ ๋ฝ ํ๋
++counter;
m.unlock(); //์์
ํ ๋ฝ ํด์
}
}
void decrement() {
for (int i = 0; i < 10000; ++i) {
m.lock();
--counter;
m.unlock();
}
}
int main() {
thread t1(increment);
thread t2(decrement);
t1.join();
t2.join();
cout << "Final counter value: " << counter << endl;
return 0;
}
์ธ๋งํฌ์ด(Semaphore)
์ธ๋งํฌ์ด๋ ๋ฎคํ ์ค์ ๋น์ทํ ๊ฐ๋ ์ด์ง๋ง ๋ฎคํ ์ค๋ ํ๋ฒ์ ํ๋๋ง ์ ๊ทผํ๋ ๊ฒ์ ๋ฐํด, ์ธ๋งํฌ์ด๋ S๊ฐ์ ํ๋ก์ธ์ค๋ ์ฐ๋ ๋๊ฐ ๋์์ ์ ๊ทผ ๊ฐ๋ฅํ๋ค.
๋ง์ฝ S๊ฐ 2๋ผ๊ณ ๊ฐ์ ํ๊ณ ๊ทธ๋ฆผ์ ์ดํด๋ณด๋๋ก ํ์.
์ฐธ๊ณ ๋ก ์ธ๋งํฌ์ด๋ ์ด์ง ์ธ๋งํฌ์ด(binary semaphore)์ ์นด์ดํ ์ธ๋งํฌ์ด(counting semaphore)๋ก ๊ตฌ๋ถ๋๋ค. ์ด์ง ์ธ๋งํฌ์ด๋ S๊ฐ 0 ๋๋ 1, ์ฆ ๋ฎคํ ์ค๋ฅผ ์๋ฏธํ๊ณ S๊ฐ ์ฌ๋ฌ๊ฐ์ ๊ฐ์ ๊ฐ์ง๋ฉด ์นด์ดํ ์ธ๋งํฌ์ด๋ผ๊ณ ํ๋ค. ๊ทธ๋ ๊ธฐ์ ์ธ๋งํฌ์ด๋ผ๊ณ ํ๋ฉด ์ผ๋ฐ์ ์ผ๋ก ์นด์ดํ ์ธ๋งํฌ์ด๋ฅผ ์๋ฏธํ๋ค.
๋ชจ๋ํฐ
๋ง์ง๋ง์ผ๋ก ๋ชจ๋ํฐ๋ ๊ณต์ ์์๊ณผ ๊ทธ ๊ณต์ ์์์ ๋ค๋ฃจ๋ ํจ์(์ธํฐํ์ด์ค)๋ก ๊ตฌ์ฑ๋ ๋๊ธฐํ ๋๊ตฌ์ด๋ค. ์์ ๋ณธ ์ธ๋งํฌ์ด๋ ๋ฎคํ ์ค์ ๋ค๋ฅธ ์ ์ ์ํธ๋ฐฐ์ ์ ๋ํด ์คํ์์ ์ ์ด๊น์ง๋ ํ๋ค๋ ์ ์ด๋ค.
๋ชจ๋ํฐ๋ฅผ ์ดํดํ๋ ค๋ฉด ๋จผ์ ์กฐ๊ฑด๋ณ์๋ผ๋ ๊ฒ์ ๋ํด ์๊ณ ์์ด์ผ ํ๋ค. ์กฐ๊ฑด๋ณ์๋ ์คํ ์์ ์ ์ด๋ฅผ ์ํ ๋๊ธฐํ ๋๊ตฌ๋ก, ํน์ ์กฐ๊ฑด์์ ํ๋ก์ธ์ค๋ฅผ ์คํ/์ค๋จํจ์ผ๋ก์จ ํ๋ก์ธ์ค๋ ์ฐ๋ ๋์ ์คํ ์์๋ฅผ ์ ์ดํ ์ ์๋ค. ์กฐ๊ฑด ๋ณ์์๋ wait, signalํจ์๊ฐ ์๋๋ฐ ํ๋ก์ธ์ค๋ฅผ ์คํํ ์ ์๋ ์ํฉ(์ ํ์กฐ๊ฑด ๋ถ์ถฉ์กฑ)์๋ wait์, ํ๋ก์ธ์ค๋ฅผ ์คํํ ์ ์๋ ์ํฉ(์ ํ์กฐ๊ฑด ์ถฉ์กฑ)์๋ signal์ ํตํด ์คํ์ ์ฌ๊ฐํ๋ค.
๋ชจ๋ํฐ์ ์๋ ์๋ฆฌ๋ ๋ค์๊ณผ ๊ฐ๋ค.
ํ๋ก์ธ์ค ๋ฐ ์ฐ๋ ๋๋ ๊ณต์ ์์์ ์ ๊ทผํ๊ธฐ ์ํด ๋ฐ๋์ ์ ํด์ง ๊ณต์ ์์ ์ฐ์ฐ(๋ชจ๋ํฐ์ ์ธํฐํ์ด์ค)์ ํตํด ๋ชจ๋ํฐ ๋ด๋ก ์ง์ ํด์ผํ๋ค.
๋ชจ๋ํฐ ์์ ์ง์ ํ์ฌ ์คํ๋๋ ํ๋ก์ธ์ค ๋ฐ ์ฐ๋ ๋๋ ํญ์ ํ๋์ฌ์ผ ํ๋ค.
๋ง์ผ ์ด๋ฏธ ๋ชจ๋ํฐ ๋ด์ ์ง์ ํ์ฌ ์คํ์ค์ธ ํ๋ก์ธ์ค๋ ์ฐ๋ ๋๊ฐ ์๋ค๋ฉด ํ์์ ๋๊ธฐํด์ผ ํ๋ค.
์กฐ๊ฑด ๋ณ์๋ฅผ ํ์ฉํด ์์ง ์คํํ ์ ์๋ ํ๋ก์ธ์ค๋ ์ฐ๋ ๋๋ ๋๊ธฐ์ํ๋ก ์ ์ด๋ค๊ฒ ํ๋ค.
์ค์ ์์๋ฅผ ๋ณด๋๋ก ํ์.
๋ง์ผ A→B์์ผ๋ก ์คํ๋์ด์ผ ํ๋๋ฐ ์๋์ ๊ฐ์ด B๊ฐ ํ์ ์์ชฝ์ ์๋ค๊ณ ๊ฐ์ ํ์.
๊ทธ๋ผ B๋ A๊ฐ ์์ง ์คํ๋์ง ์์์ผ๋ ๋๊ธฐ์ํ์ ์ ์ด๋ค๊ณ , A๊ฐ ์คํ๋๊ฒ ๋๋ค.
์ดํ A์ ์คํ์ด ์๋ฃ๋๋ฉด signal์ ํธ์ถํ๊ฒ ๋๊ณ , B๊ฐ ์คํ๋๋ค.
์ด๋ ๊ฒ ์กฐ๊ฑด ๋ณ์๋ฅผ ํ์ฉํ๊ธฐ ๋๋ฌธ์ ๋ชจ๋ํฐ๋ ์ํธ๋ฐฐ์ ์ ์คํ์์์ ์ด๋ฅผ ๋ชจ๋ ์ํํ ์ ์๋ ๊ฒ์ด๋ค. ์ฐธ๊ณ ๋ก ์๋ฐ์ synchronized ํค์๋๊ฐ ๋ชจ๋ํฐ๋ฅผ ์ฌ์ฉํ๋ ๋ํ์ ์ธ ์์์ด๋ค. synchronized ํค์๋๋ฅผ ์ฌ์ฉํ ๋ฉ์๋๋ ํ๋์ ํ๋ก์ธ์ค ๋ฐ ์ฐ๋ ๋๋ง ์คํํ ์ ์๋ค.
์ฐ๋ ๋ ์์ (Thread Safe)
์์์ ๊ฐ์ด ๋ฉํฐ์ฐ๋ ๋ ํ๊ฒฝ์์ ์ด๋ค ๋ณ์๋ ํจ์, ๊ฐ์ฒด์ ๋์ ์ ๊ทผ์ด ์ด๋ฃจ์ด์ ธ๋ ๋ฌธ์ ๊ฐ ์๋ ์ํ๋ฅผ ์ฐ๋ ๋ ์์ (thread safe)ํ๋ค๊ณ ํ๋ค. ๋์ ์ ๊ทผ์ด ์ด๋ฃจ์ด์ ธ๋ ๋ ์ด์ค ์ปจ๋์ ์ด ๋ฐ์ํ์ง ์๋๋ค๋ ๋ป์ด๋ค.
์๋ฐ์์ Vectorํด๋์ค์ add ๋ฉ์๋๋ ์ฐ๋ ๋ ์์ ์ฑ์ด ๋ณด์ฅ๋์ด์๋ค. add๋ฉ์๋๋ ๋ด๋ถ์ ์ผ๋ก synchronized ํค์๋๋ก ๊ตฌํ๋์ด ์๊ธฐ ๋๋ฌธ์ด๋ค.
๋ฐ๋ฉด ArrayListํด๋์ค์ add ๋ฉ์๋๋ ์ฐ๋ ๋ ์์ ์ฑ์ด ๋ณด์ฅ๋์ง ์๋๋ค.
'Computer Science > ์ด์์ฒด์ ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๊ต์ฐฉ ์ํ(Deadlock) (0) | 2025.06.30 |
---|---|
ํ๋ก์ธ์ค, ์ฐ๋ ๋, ๋๊ธฐํ (0) | 2025.06.19 |
์ด์์ฒด์ ๊ฐ์ (0) | 2025.05.24 |