Race Condition
โข
race condition์ด๋ ๋ ๊ฐ ์ด์์ ํ๋ก์ธ์ค๊ฐ ๊ณตํต ์์์ ๋ณํ์ ์ผ๋ก(concurrently) ์ฝ๊ฑฐ๋ ์ฐ๋ ๋์์ ํ ๋, ๊ณต์ฉ ๋ฐ์ดํฐ์ ๋ํ ์ ๊ทผ์ด ์ด๋ค ์์์ ๋ฐ๋ผ ์ด๋ฃจ์ด์ก๋์ง์ ๋ฐ๋ผ ๊ทธ ์คํ ๊ฒฐ๊ณผ๊ฐ ๊ฐ์ง ์๊ณ ๋ฌ๋ผ์ง๋ ์ํฉ์ ๋งํ๋ค.
โข
Race์ ๋ป ๊ทธ๋๋ก, ๊ฐ๋จํ ๋งํ๋ฉด ๊ฒฝ์ํ๋ ์ํ, ์ฆ ๋ ๊ฐ์ ์ค๋ ๋๊ฐ ํ๋์ ์์์ ๋๊ณ ์๋ก ์ฌ์ฉํ๋ ค๊ณ ๊ฒฝ์ํ๋ ์ํฉ์ ๋งํ๋ค.
Race Condition์ด ๋ฐ์ํ๋ ๊ฒฝ์ฐ
1.
์ปค๋ ์์
์ ์ํํ๋ ์ค์ ์ธํฐ๋ฝํธ ๋ฐ์
โข
๋ฌธ์ ์ : ์ปค๋๋ชจ๋์์ ๋ฐ์ดํฐ๋ฅผ ๋ก๋ํ์ฌ ์์
์ ์ํํ๋ค๊ฐ ์ธํฐ๋ฝํธ๊ฐ ๋ฐ์ํ์ฌ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๋ ๊ฒฝ์ฐ
โข
ํด๊ฒฐ๋ฒ : ์ปค๋๋ชจ๋์์ ์์
์ ์ํํ๋ ๋์, ์ธํฐ๋ฝํธ๋ฅผ disable ์์ผ CPU ์ ์ด๊ถ์ ๊ฐ์ ธ๊ฐ์ง ๋ชปํ๋๋ก ํ๋ค.
2.
ํ๋ก์ธ์ค๊ฐ 'System Call'์ ํ์ฌ ์ปค๋ ๋ชจ๋๋ก ์ง์
ํ์ฌ ์์
์ ์ํํ๋ ๋์ค ๋ฌธ๋งฅ ๊ตํ์ด ๋ฐ์ํ ๋
โข
๋ฌธ์ ์ : ํ๋ก์ธ์ค1์ด ์ปค๋๋ชจ๋์์ ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๋ ๋์ค, ์๊ฐ์ด ์ด๊ณผ๋์ด CPU ์ ์ด๊ถ์ด ํ๋ก์ธ์ค2๋ก ๋์ด๊ฐ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ์กฐ์ํ๋ ๊ฒฝ์ฐ ( ํ๋ก์ธ์ค2๊ฐ ์์
์ ๋ฐ์๋์ง ์์ )
โข
ํด๊ฒฐ๋ฒ : ํ๋ก์ธ์ค๊ฐ ์ปค๋๋ชจ๋์์ ์์
์ ํ๋ ๊ฒฝ์ฐ ์๊ฐ์ด ์ด๊ณผ๋์ด๋ CPU ์ ์ด๊ถ์ด ๋ค๋ฅธ ํ๋ก์ธ์ค์๊ฒ ๋์ด๊ฐ์ง ์๋๋ก ํจ
3.
๋ฉํฐ ํ๋ก์ธ์ ํ๊ฒฝ์์ ๊ณต์ ๋ฉ๋ชจ๋ฆฌ ๋ด์ ์ปค๋ ๋ฐ์ดํฐ์ ์ ๊ทผํ ๋
โข
๋ฌธ์ ์ : ๋ฉํฐ ํ๋ก์ธ์ ํ๊ฒฝ์์ 2๊ฐ์ CPU๊ฐ ๋์์ ์ปค๋ ๋ด๋ถ์ ๊ณต์ ๋ฐ์ดํฐ์ ์ ๊ทผํ์ฌ ์กฐ์ํ๋ ๊ฒฝ์ฐ
โข
ํด๊ฒฐ๋ฒ : ์ปค๋ ๋ด๋ถ์ ์๋ ๊ฐ ๊ณต์ ๋ฐ์ดํฐ์ ์ ๊ทผํ ๋๋ง๋ค, ๊ทธ ๋ฐ์ดํฐ์ ๋ํ lock/unlock์ ํ๋ ๋ฐฉ๋ฒ
์๊ณ ๊ตฌ์ญ (Critical Section)
โข
์ฌ๋ฌ ํ๋ก์ธ์ค๊ฐ ๋ฐ์ดํฐ๋ฅผ ๊ณต์ ํ๋ฉฐ ์ํ๋ ๋,ย ๊ฐ ํ๋ก์ธ์ค์์ ๊ณต์ ๋ฐ์ดํฐ๋ฅผ ์ ๊ทผํ๋ ํ๋ก๊ทธ๋จ ์ฝ๋ ๋ถ๋ถ
โข
๊ณต์ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ํ๋ก์ธ์ค๊ฐ ๋์์ ์ ๊ทผํ ๋ ์๋ชป๋ ๊ฒฐ๊ณผ๋ฅผ ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์, ํ ํ๋ก์ธ์ค๊ฐ ์๊ณ ๊ตฌ์ญ์ ์ํํ ๋๋ ๋ค๋ฅธ ํ๋ก์ธ์ค๊ฐ ์ ๊ทผํ์ง ๋ชปํ๋๋ก ํด์ผ ํ๋ค.
์ธ๋งํฌ์ด(Semaphore)
โข
๊ณต์ ๋ ์์์ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ํ๋ก์ธ์ค๊ฐ ์ ๊ทผํ๋ ๊ฒ์ ๋ง๋ ๋ฐฉ๋ฒ์ด๋ค.
โข
๋ํ ์ธ๋งํฌ์ด๋ ๋ฆฌ์์ค์ ์ํ๋ฅผ ๋ํ๋ด๋ ๊ฐ๋จํ ์นด์ดํฐ๋ผ๊ณ ํ ์ ์๋ค.
โข
ํ๋์ ์ค๋ ๋๋ง ๋ค์ด๊ฐ๊ฒ ํ ์๋ ์๊ณ ์ฌ๋ฌ ๊ฐ์ ์ค๋ ๋๊ฐ ๋ค์ด๊ฐ๊ฒ ํ ์ ์๋ค. ์ด๊ฒ์ด ๋ฎคํ
์ค์์ ์ฐจ์ด์ด๋ค.
โข
Spin Up ๋ฐฉ์๊ณผ Block & wakeup 2๊ฐ์ง ๋ฐฉ์์ด ์กด์ฌํ๋ค. ํ์ง๋ง Spin Up ๋ฐฉ์์ CPU๋ฅผ ๊ณ์ ์ ์ ํ๊ณ ์๊ธฐ ๋๋ฌธ์ busy-waiting์ด ๋ฐ์ํ๋ค.
์ธ๋งํฌ์ด์ P, V ์ฐ์ฐ (Block & Wakeup ๋ฐฉ์)
P : ์๊ณ ๊ตฌ์ญ ๋ค์ด๊ฐ๊ธฐ ์ ์ ์ํ ( ํ๋ก์ธ์ค ์ง์
์ฌ๋ถ๋ฅผ ์์์ ๊ฐ์(S)๋ฅผ ํตํด ๊ฒฐ์ )
์ปค๋์ wait ( == block )์ ํธ์ถํ ํ๋ก์ธ์ค๋ฅผ suspend ์ํค๊ณ ์ด ํ๋ก์ธ์ค์ PCB๋ฅผ ์ธ๋งํฌ์ด์ ๋ํ wait queue์ ๋ฃ๋๋ค.
V : ์๊ณ ๊ตฌ์ญ์์ ๋์ฌ ๋ ์ํ ( ์์ ๋ฐ๋ฉ ์๋ฆผ, ๋๊ธฐ ์ค์ธ ํ๋ก์ธ์ค๋ฅผ ๊นจ์ฐ๋ ์ ํธ )
block๋ ํ๋ก์ธ์ค๋ฅผ wakeup ์ํค๊ณ ์ด ํ๋ก์ธ์ค์ PCB๋ฅผ ready queue๋ก ์ฎ๊ธด๋ค.
procedure P(S) --> ์ต์ด S๊ฐ์ 1์
while S=0 do wait --> S๊ฐ 0๋ฉด 1์ด ๋ ๋๊น์ง ๊ธฐ๋ค๋ ค์ผ ํจ
S := S-1 --> S๋ฅผ 0๋ก ๋ง๋ค์ด ๋ค๋ฅธ ํ๋ก์ธ์ค๊ฐ ๋ค์ด ์ค์ง ๋ชปํ๋๋ก ํจ
end P
--- ์๊ณ ๊ตฌ์ญ ---
procedure V(S) --> ํ์ฌ์ํ๋ S๊ฐ 0์
S := S+1 --> S๋ฅผ 1๋ก ์์์น์์ผ ํด์ ํ๋ ๊ณผ์
end V
C
๋ณต์ฌ
๋ฎคํ ์ค (Mutex)
โข
์ํธ ๋ฐฐ์ (Mutual Exclusion)์ ์ฝ์๋ก ์๊ณ ๊ตฌ์ญ์ ๊ฐ์ง ์ค๋ ๋๋ค์ ์คํ์๊ฐ์ด ์๋ก ๊ฒน์น์ง ์๊ณ ๊ฐ๊ฐ ๋จ๋
์ผ๋ก ์คํ๋๊ฒ ํ๋ ๊ธฐ์ ์ด๋ค.
โข
ํด๋น ์ ๊ทผ์ ์กฐ์จํ๊ธฐ ์ํด lock๊ณผ unlock์ ์ฌ์ฉํ๋ค.
โฆ
lock : ํ์ฌ ์๊ณ ๊ตฌ์ญ์ ๋ค์ด๊ฐ ๊ถํ์ ์ป์ด์ด ( ๋ง์ฝ ๋ค๋ฅธ ํ๋ก์ธ์ค/์ค๋ ๋๊ฐ ์๊ณ ๊ตฌ์ญ ์ํ ์ค์ด๋ฉด ์ข
๋ฃํ ๋๊น์ง ๋๊ธฐ )
โฆ
unlock : ํ์ฌ ์๊ณ ๊ตฌ์ญ์ ๋ชจ๋ ์ฌ์ฉํ์์ ์๋ฆผ. ( ๋๊ธฐ ์ค์ธ ๋ค๋ฅธ ํ๋ก์ธ์ค/์ค๋ ๋๊ฐ ์๊ณ ๊ตฌ์ญ์ ์ง์
ํ ์ ์์ )
โข
๋ฎคํ
์ค๋ ์ํ๊ฐ 1, 0 ๋ฐ์ ์๊ณ , ์ด์ง ์ธ๋งํฌ์ด๋ผ๊ณ ๋ถ๋ฅด๊ธฐ๋ ํ๋ค.
๋ฎคํ ์ค ์๊ณ ๋ฆฌ์ฆ
1.
๋ฐ์ปค(Dekker) ์๊ณ ๋ฆฌ์ฆ
flag์ turn ๋ณ์๋ฅผ ํตํด ์๊ณ ๊ตฌ์ญ์ ๋ค์ด๊ฐ ํ๋ก์ธ์ค/์ค๋ ๋๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐฉ์
โข
flag : ํ๋ก์ธ์ค ์ค ๋๊ฐ ์๊ณ์์ญ์ ์ง์
ํ ๊ฒ์ธ์ง ๋ํ๋ด๋ ๋ณ์
โข
turn : ๋๊ฐ ์๊ณ๊ตฌ์ญ์ ๋ค์ด๊ฐ ์ฐจ๋ก์ธ์ง ๋ํ๋ด๋ ๋ณ์
while(true) {
flag[i] = true; // ํ๋ก์ธ์ค i๊ฐ ์๊ณ ๊ตฌ์ญ ์ง์
์๋
while(flag[j]) { // ํ๋ก์ธ์ค j๊ฐ ํ์ฌ ์๊ณ ๊ตฌ์ญ์ ์๋์ง ํ์ธ
if(turn == j) { // j๊ฐ ์๊ณ ๊ตฌ์ญ ์ฌ์ฉ ์ค์ด๋ฉด
flag[i] = false; // ํ๋ก์ธ์ค i ์ง์
์ทจ์
while(turn == j); // turn์ด j์์ ๋ณ๊ฒฝ๋ ๋๊น์ง ๋๊ธฐ
flag[i] = true; // j turn์ด ๋๋๋ฉด ๋ค์ ์ง์
์๋
}
}
}
// ------- ์๊ณ ๊ตฌ์ญ ---------
turn = j; // ์๊ณ ๊ตฌ์ญ ์ฌ์ฉ ๋๋๋ฉด turn์ ๋๊น
flag[i] = false; // flag ๊ฐ์ false๋ก ๋ฐ๊ฟ ์๊ณ ๊ตฌ์ญ ์ฌ์ฉ ์๋ฃ๋ฅผ ์๋ฆผ
C
๋ณต์ฌ
2. ํผํฐ์จ (Peterson) ์๊ณ ๋ฆฌ์ฆ
๋ฐ์ปค์ ์ ์ฌํ์ง๋ง, ์๋๋ฐฉ ํ๋ก์ธ์ค/์ค๋ ๋์๊ฒ ์ง์
๊ธฐํ๋ฅผ ์๋ณดํ๋ ๊ฒ์ ์ฐจ์ด๊ฐ ์์
while(true) {
flag[i] = true; // ํ๋ก์ธ์ค i๊ฐ ์๊ณ ๊ตฌ์ญ ์ง์
์๋
turn = j; // ๋ค๋ฅธ ํ๋ก์ธ์ค์๊ฒ ์ง์
๊ธฐํ ์๋ณด
while(flag[j] && turn == j) { // ๋ค๋ฅธ ํ๋ก์ธ์ค๊ฐ ์ง์
์๋ํ๋ฉด ๋๊ธฐ
}
}
// ------- ์๊ณ ๊ตฌ์ญ ---------
flag[i] = false; // flag ๊ฐ์ false๋ก ๋ฐ๊ฟ ์๊ณ ๊ตฌ์ญ ์ฌ์ฉ ์๋ฃ๋ฅผ ์๋ฆผ
C
๋ณต์ฌ
3. ์ ๊ณผ์ (Bakery) ์๊ณ ๋ฆฌ์ฆ
์ฌ๋ฌ ํ๋ก์ธ์ค/์ค๋ ๋์ ๋ํ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํ ์๊ณ ๋ฆฌ์ฆ. ๊ฐ์ฅ ์์ ์์ ๋ฒํธํ๋ฅผ ๊ฐ์ง๊ณ ์๋ ํ๋ก์ธ์ค๊ฐ ์๊ณ ๊ตฌ์ญ์ ์ง์
ํ๋ค.
while(true) {
isReady[i] = true; // ๋ฒํธํ ๋ฐ์ ์ค๋น
number[i] = max(number[0~n-1]) + 1; // ํ์ฌ ์คํ ์ค์ธ ํ๋ก์ธ์ค ์ค์ ๊ฐ์ฅ ํฐ ๋ฒํธ ๋ฐฐ์
isReady[i] = false; // ๋ฒํธํ ์๋ น ์๋ฃ
for(j = 0; j < n; j++) { // ๋ชจ๋ ํ๋ก์ธ์ค ๋ฒํธํ ๋น๊ต
while(isReady[j]); // ๋น๊ต ํ๋ก์ธ์ค๊ฐ ๋ฒํธํ ๋ฐ์ ๋๊น์ง ๋๊ธฐ
while(number[j] && number[j] < number[i] && j < i);
// ํ๋ก์ธ์ค j๊ฐ ๋ฒํธํ ๊ฐ์ง๊ณ ์์ด์ผ ํจ
// ํ๋ก์ธ์ค j์ ๋ฒํธํ < ํ๋ก์ธ์ค i์ ๋ฒํธํ
}
}
// ------- ์๊ณ ๊ตฌ์ญ ---------
number[i] = 0; // ์๊ณ ๊ตฌ์ญ ์ฌ์ฉ ์ข
๋ฃ
C
๋ณต์ฌ