게임 개발에서 주로 게임을 관리하는 매니저 계열의 클래스를 만들 때 적합하며, (딱 하나만 필요)
사운드를 재생하려 할 때, 관련된 정보를 어디에서나 알게 하여 누구나 재생할 수 있도록 하기 위해(전역적 접근)
사용한다고 생각하면 된다.
⭐ 특징
Lazy 초기화(Lazy initialization) :선언 즉시 인스턴스를 생성하는 것이 아니라, 처음 접근할 때 객체를 생성한다.
상속 가능 : 하위 클래스 오브젝트도 모두 싱글톤이 된다.
1. 안전하지 않은 버전 - not thread-safe
publicclassSingletonClass
{
privateSingletonClass() { } //클래스의 외부에서 함부로 객체를 만들 수 없게 함 privatestatic SingletonClass instance; //객체 생성 이후 생성된 것만 꺼내서 사용함 publicstatic SingletonClass Instance
{
get
{
if(instance == null) //인스턴스가 비어있는 경우에만 -> 생성되지 않았을 때,
{
instance = new SingletonClass(); //새 객체를 생성해서 instance에 변수에 넣어줌
}
return instance;
}
}
}
단 하나의 인스턴스만 생성해야 하므로 외부에서 객체를 생성할 수 없도록 private 접근 지정자를 설정한다.
인스턴스가 null인지를 체크하여 비어있을 때만 새 객체를 만든다.
하지만 이 코드는 스레드로부터 안전하지 않다.
서로다른 A,B 스레드가 모두 if(instance == null) 조건을 만족한다면, A와 B 모두 인스턴스를 생성하게 되어
pending이 true일 때는, 아까 말한 거꾸로 메시지를 알려주도록 하는 작업을 해보자.
초기화 함수에 넣어주어 처음 시작 때 무조건 한번 실행되도록 할 것이다.
public void Init(IPEndPoint endPoint)
{
...//(위 코드 참고)SocketAsyncEventArgs args = new SocketAsyncEventArgs();
args.Completed+= new EventHandler<SocketAsyncEventArgs>(OnAcceptCompleted);
RegisterAccept(args);
}
EventHandler를 사용하기 위해 콜백 함수인 OnAcceptCompleted를 넣어주고,
classProgram
{
static Listener _listener = new Listener();
staticvoidOnAcceptHandler(Socket clientSocket)
{
try
{
//받는다byte[] recvBuff = newbyte[1024];
int recvBytes = clientSocket.Receive(recvBuff);
String recvData = Encoding.UTF8.GetString(recvBuff, 0, recvBytes);
Console.WriteLine($"[From Client] {recvData}");
//보낸다byte[] sendBuff = Encoding.UTF8.GetBytes("Welcome to MMORPG Server !");
clientSocket.Send(sendBuff);
//쫓아낸다.
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
}
catch(Exception e)
{
Console.WriteLine(e.ToString());
}
}
staticvoidMain(string[] args)
{
//DNS (Domain Name System)//도메인 등록 후 -> IP주소 찾게끔 만들면 유지보수가 용이함 string host = Dns.GetHostName(); //PC의 호스트명을 받는다 (호스트명은 IP 주소 대신 사용할 수 있는 식별 이름)
IPHostEntry ipHost = Dns.GetHostEntry(host); //해당 호스트의 IP 관련 주소들을 받는다.
IPAddress ipAddr = ipHost.AddressList[0]; //여러개의 주소를 담고있는 리스트를 반환하며 이중 첫번째 값을 할당한다(여러개의 주소를 뱉어주는 경우도 있음)
IPEndPoint endPoint = new IPEndPoint(ipAddr, 7777); //7777은 포트 번호 , IP 주소와 포트 번호를 할당한다.
_listener.Init(endPoint,OnAcceptHandler);
Console.WriteLine("Listening...");
while (true)
{
;
}
}
}
//DNS (Domain Name System)//도메인 등록 후 -> IP주소 찾게끔 만들면 유지보수가 용이함//PC의 호스트명을 받는다 (호스트명은 IP 주소 대신 사용할 수 있는 식별 이름) string host = Dns.GetHostName();
IPHostEntry ipHost = Dns.GetHostEntry(host); //해당 호스트의 IP 관련 주소들을 받는다.
IPAddress ipAddr = ipHost.AddressList[0]; //여러개의 주소를 담고있는 리스트를 반환하며 이중 첫번째 값을 할당한다(여러개의 주소를 뱉어주는 경우도 있음)
IPEndPoint endPoint = new IPEndPoint(ipAddr, 7777); //7777은 포트 번호 , IP 주소와 포트 번호를 할당한다.
IPHostEntry :DNS 클래스의 GetHostEntry의 반환 값을 담는 컨테이너 클래스. 호스트 관련 정보와 IP관련 정보를 받는다.
IPAddress :하나의 인터페이스에 대한 주소를 포함하는 클래스. 첫번 째 인덱스에 담긴 IP 주소를 할당한다.
IPEndPoint :IP 주소와 포트를 바인딩하여 소켓과 원격 주소를 연결한다.
⭐ 서버 코드
//문지기
Socket listenSocket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try{
//문지기 교육
listenSocket.Bind(endPoint);
// 영업 시작// backlog : 최대 대기수
listenSocket.Listen(10);
while (true)
{
Console.WriteLine("Listening....");
// 손님을 입장시킨다
Socket clientSocket = listenSocket.Accept();
// 받는다 byte[] recvBuff = newbyte[1024];
int recvBytes = clientSocket.Receive(recvBuff);
string recvData = Encoding.UTF8.GetString(recvBuff, 0, recvBytes);
Console.WriteLine($"[From Client] {recvData}");
// 보낸다byte[] sendBuff = Encoding.UTF8.GetBytes("Welcome to MMORPG Server !");
clientSocket.Send(sendBuff);
// 쫒아낸다
clientSocket.Shutdown(SocketShutdown.Both);
clientSocket.Close();
}
}catch(Exception e)
{
Console.Write(e.ToString());
}
문지기를 만든다 -> 서버 소켓을 만든다 (IP관련 정보와 소켓 타입, 연결 방법(프로토콜 설정)을 결정한다.
endPoint를 바인드 한다 (* endPoint :IP주소와 포트 번호의 조합)
클라이언트를 입장 시키고, 클라이언트가 전달하려는 내용을 받는다. (문자열을 전달하는 간단 예제)
클라이언트에게 서버 응답을 전달한다
후 연결을 종료한다 (* shut down : 현재 연결된 프로세스의 개수에 상관없이 연결을 종료한다. close:연결된 개수가 0이 되어야지만 연결이 종료된다. 소켓을 메모리 상에서 완전 해제하려면 shutdown 후에 close를 해 줘야 한다)
⭐ 클라이언트 코드
//클라이언트 소켓 설정
Socket socket = new Socket(endPoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
try{
// 문지기에게 입장 문의
socket.Connect(endPoint);
Console.WriteLine($"Connected To {socket.RemoteEndPoint.ToString()}");
// 보낸다 byte[] sendBuff = Encoding.UTF8.GetBytes("Connected Client !");
int sendBytes = socket.Send(sendBuff);
// 받는다byte[] recvBuff = newbyte[1024];
int recvBytes = socket.Receive(recvBuff);
string recvData = Encoding.UTF8.GetString(recvBuff, 0, recvBytes);
Console.WriteLine($"[From Server] {recvData}");
// 종료
socket.Shutdown(SocketShutdown.Both);
socket.Close();
}catch(Exception e)
{
Console.Write(e.ToString);
}
1) Thread.CurrentThread.ManagedThreadId를 통해 현재 스레드 Id를 얻고,
WRITE_MASK와의 논리 연산을 통해 desire 값으로 초기화 한다.
2) _flag의 값을 확인하면서 lock을 획득하고 있는 지 아닌지를 반복문을 돌면서 확인한다.
3) _flag 값이 EMPTY_FLAG와 동일하면 _flag값에 desire 값을 할당한다
(진입하여 lock을 획득한 다음, 반복문을 나온다. ❗ 이 때, Interlocked의 compareExchange를 활용해 값을
비교하고 초기화 하는 작업이 한 번에 이루어 지도록 한다. )
4) 5천번 이상 시도를 했을 때는, Yield()를 통해 다른 스레드에게 점유를 넘긴다.
👉 WriteUnLock
1) 쓰기가 종료되면 락을 풀어 주어야 한다.
_flag 값을 다시 초기값(EMPTY_FLAG == 0) 으로 바꾼다.
publicvoidWriteLock()
{
// 아무도 WriteLock or ReadLock을 획득하고 있지 않을 때, 경합해서 소유권을 얻는다int desire = (Thread.CurrentThread.ManagedThreadId << 16) & WRITE_MASK;
while (true)
{
for (int i = 0; i < MAX_SPIN_COUNT; i++)
{
if (Interlocked.CompareExchange(ref _flag, desire, EMPTY_FLAG) == EMPTY_FLAG)
{
return;
}
Thread.Yield();
}
}
}
publicvoidWriteUnlock()
{
Interlocked.Exchange(ref _flag, EMPTY_FLAG);
}
4️⃣ ReadLock과 ReadUnlock 구현하기
1️⃣ Readlock
1) _flag와 READ_MASK 논리 연산 값을 expected에 할당한다.
(읽을 수 있는 지 여부를 확인하기 위한 변수 설정)
2) _flag와 expected 값이 같으면, expected 값을 1 증가 (write 상태가 아님을 의미)
3) 최대 시도 횟수를 넘어가면 다른 스레드에게 Yield()를 통해 양보한다.
👉 ReadUnlock
1) 락을 풀어주기 위해 증가시켰던 값을 Interlocked 통해 감소시킨다
publicvoidReadLock()
{
while (true)
{
for (int i = 0; i < MAX_SPIN_COUNT; i++)
{
int expected = (_flag & READ_MASK);
if (Interlocked.CompareExchange(ref _flag, expected + 1, expected) == expected)
return;
//해당 방법은 스레드 동기화가 잘 이루어지지 않는 문제 발생 -> 한번에 처리하는 코드로 바꿔야 함 /*if((_flag & WRITE_MASK) == 0)
{
_flag = _flag + 1;
return;
}*/
}
Thread.Yield();
}
}
publicvoidReadUnlock()
{
Interlocked.Decrement(ref _flag); // 1을 줄임
}
👉 재귀적 락을 허용하는 경우
재귀적 락을 허용하는 경우란 다음 경우를 말한다.
동일 스레드 내에서(Write 스레드가) 하고 Write 하는 경우 Ok
Write -> Read 하는 경우도 Ok
하지만 동일 스레드 내에서 Read -> Write하는 것은 막는다.
즉, 읽으면서 쓰는 경우는 막는 것이다.
1️⃣ WriteLock과 WriteUnlock의 달라지는 점
👉 Writelock
1)현재 스레드 ID와 lock을 소유하고 있는 ID를 확인하여 이미 writelock 을 획득하고 있는 지 확인한다.
1-2) 획득하고 있으면, _writeCount 변수를 두어 값을 증가시킨다. (재귀적 허용)
소유하고 있지 않을 때는 기존과 같다.
👉 WriteUnlock
1) lock을 획득한 만큼(증가시킨 만큼) 풀어주어야 한다. _writeCount 의 값을 감소시킨다.
2) _writeCount가 0이 되었을 때, write을 unlock 시킨다. (초기 상태로 세팅한다.)
2️⃣ ReadLock과 ReadUnlock의 달라지는 점
1) 현재 스레드가 이미 writeLock을 획득하고 있는 지 확인한다.
2) 소유하고 있다면 _flag 값 자체를 증가시킨다. (_flag 값 자체가 ReadCount가 된다 - 공유 카운트)
소유하고 있지 않을 때는 동일하며 ReadUnlock 또한 동일하다.
최종 코드
// 재귀적 락을 허용할 지(No)// 재귀적 락을 허용할 지(YES) WriteLock -> WriteLock OK, WriteLock->ReadLock Ok, ReadLock -> WriteLock No// 스핀락 정책 (5000번 -> Yield)classLock
{
constint EMPTY_FLAG = 0x00000000;
constint WRITE_MASK = 0x7FFF0000;
constint READ_MASK = 0x0000FFFF;
constint MAX_SPIN_COUNT = 5000;
// [ Unused(1)] [WriteThreadId(15)] -> 한번에 한 스레드만 획득 가능 [ReadCount(16)]int _flag = EMPTY_FLAG;
int _writeCount = 0;
publicvoidWriteLock()
{
//동일 스레드가 WriteLock을 이미 획득하고 있는 지 확인int lockThreadId = (_flag & WRITE_MASK) >> 16;
if (Thread.CurrentThread.ManagedThreadId == lockThreadId)
{
_writeCount++;
return;
}
//아무도 WriteLock or ReadLock을 획득하고 있지 않을 때, 경합해서 소유권을 얻는다int desire = (Thread.CurrentThread.ManagedThreadId << 16) && WRITE_MASK;
while (true)
{
for (int i = 0; i < MAX_SPIN_COUNT; i++)
{
if (Interlocked.CompareExchange(ref _flag, desire, EMPTY_FLAG) == EMPTY_FLAG)
{
_writeCount = 1;
return;
}
/*//시도를 해서 성공하면 return
if (_flag == EMPTY_FLAG)
_flag = desire;*/
}
Thread.Yield();
}
}
publicvoidWriteUnlock()
{
int lockCount = --_writeCount;
if (lockCount == 0)
//초기 상태로 돌려줌
Interlocked.Exchange(ref _flag, EMPTY_FLAG);
}
publicvoidReadLock()
{
//동일 스레드가 WriteLock을 이미 획득하고 있는 지 확인int lockThreadId = (_flag & WRITE_MASK) >> 16;
if (Thread.CurrentThread.ManagedThreadId == lockThreadId)
{
Interlocked.Increment(ref _flag);
return;
}
//아무도 WriteLock을 획득하고 있지 않으면, ReadCount를 1 늘린다. while (true)
{
for (int i = 0; i < MAX_SPIN_COUNT; i++)
{
int expected = (_flag & READ_MASK);
if (Interlocked.CompareExchange(ref _flag, expected + 1, expected) == expected)
return;
//해당 방법은 스레드 동기화가 잘 이루어지지 않는 문제 발생 -> 한번에 처리하는 코드로 바꿔야 함 /*if((_flag & WRITE_MASK) == 0)
{
_flag = _flag + 1;
return;
}*/
}
Thread.Yield();
}
}
publicvoidReadUnlock()
{
Interlocked.Decrement(ref _flag); // 1을 줄임
}
}
메인 실행문
staticvolatileint count = 0;
static Lock _lock = new Lock();
staticvoidMain(string[] args)
{
Task t1 = new Task(delegate ()
{
for (int i = 0; i < 100000; i++)
{
_lock.WriteLock();
count++;
_lock.WriteUnlock();
}
});
Task t2 = new Task(delegate ()
{
for(int i=0; i < 100000; i++)
{
_lock.ReadLock();
count--;
_lock.ReadUnlock();
}
});
t1.Start();
t2.Start();
Task.WaitAll(t1, t2);
Console.WriteLine(count);
}
⭐ 정리(재귀적 허용일 때)
WriteLock 메소드 : 스레드 Id를 확인하여 write 락을 소유하고 있는 지 확인한다.
다른 스레드는 현재 스레드가 소유권을 포기하기 전까지 대기 상태로 있어야 한다.
(소유권은 한 스레드만 획득 가능)
동일한 스레드가 소유권을 또 가지려고 할 때, 별도의 _writeCount 변수를 두어 이 값을 증가시킨다.
WriteUnlock 메소드 : _writeCount 가 증가된 만큼 감소시키고 그 값이 0이 되면 락을 해제한다.
ReadLock 메소드 : write을 소유하고 있지 않을 때, 다수의 스레드가 경합하여 공유 카운트를 올리게 한다.
두 개 이상의 프로세스가 서로의 작업이 끝나기만을 기다림. 둘 다 대기상태에 이르러 영원히 끝나지 않은 상황이다.
교착 상태라고도 말한다.
👉 한정된 자원을 얻기 위해 서로 경쟁하기 때문에 발생한다.
🔎 DeadLock의 4가지 필요 조건
아래 4가지 조건이 모두 만족되는 경우, 데드락이 발생하라 가능성이 있음
하나라도 만족하지 않으면 절대로 발생하지 않는다. -> 하나라도 해결되면, 데드락 문제를 풀 수 있다.
• 상호 배제(Mutual Exclusion)
하나의 자원은 한 번에 한 프로세스만 사용할 수 있다. 임계 영역(Critical Section)을 뜻한다.
• 점유와 대기(Hold and wait)
어떤 프로세스가 하나 이상의 자원을 점유하고 있으면서 다른 프로세스가 가지고 있는 자원을 기다림
• 비선점(No Preemption)
프로세스가 작업을 마친 후, 자원을 자발적으로 반환할 때 까지 기다림(강제로 뺏지 않는다)
다른 프로세스 혹은 스레드가 획득한 자원이 반환될 때 까지 기다림을 뜻한다.
• 환형 대기(Circular Wait)
Hold and Wait 관계의 프로세스들이 서로를 기다림
T1(A -> B), T2(B -> C), T3(C -> D), T4(D -> A) 와 같이 서로가 물려있는 상태를 뜻한다.
💥 해결 방법
1. 상호배제 제거
자원 공유를 가능하게 한다 -> 거의 불가능
싱글 스레드거나 공유 데이터가 없으면 상호배제 영역이 제거 된다.
2. 점유대기 제거
lock 거는 코드를 제거한다. 프로세스 실행 전 모든 자원을 할당한다.
3. 비선점 제거
이미 걸려있는 lock을 임의로 해제한다.
자원 점유 중인 프로세스가 다른 자원을 요구할 때 가진 자원을 보내도록 한다.
4. 순환대기 제거
lock에 방향성을 넣어, 하나의 방향으로만 lock을 걸도록 처리한다.
코드를 보며 이해해 보자.
class SessionManager
{
static object _lock = new object();
public static void TestSession()
{
lock (_lock)
{
// SessionManager의 작업을 여기서 수행
}
}
public static void Test()
{
lock (_lock)
{
UserManager.TestUser();
}
}
}
class UserManager
{
static object _lock = new object();
public static void Test()
{
lock (_lock)
{
SessionManager.TestSession();
}
}
public static void TestUser()
{
lock (_lock)
{
// UserManager의 작업을 여기서 수행
}
}
}
SessionManager와 UserManager 클래스의 Test 메소드는 각각의 고유한 TestSession과 TestUser를 호출하고 있다.
SessionManager를 먼저 보면, Test의 크리티컬 섹션에서 UserManager의 TestUser를 실행하려고 호출했지만,
이미 TestUser 메소드는 lock에 걸려 선점된 상태이다. SessionManager는 선점된 상태를 그저 바라볼 뿐이다.
UserManager에서의 Test 메소드에서 또한 SessionManager의 TestSession 메소드를 호출했다.
하지만 해당 메소드는 이미 선점되어서 lock이 걸린 형태이다. UserManager도 이를 바라 볼 뿐이다.
이렇게 서로의 작업이 끝나기만을 기다리는 상태가 교착상태(DeadLock)이다.
쉽게 말해서, A는 나이프를 선점한 상태(갖고 있는)에서 B에게 포크를 달라 하고 있고, B는 포크를 선점한 상태(갖고 있는) 에서 A에게 나이프를 달라고 하며 서로 대기하는 상태인 것이다.
📌 SpinLock 이란?
lock은 상호 배타적 특성을 구현하는 방법이라 할 수 있다.
스핀락은 락의 한 종류로 루프를 돌면서 계속 점유를 시도하는 방법을 채택하는 락이다.
스레드 동기화(Thread-safe)를 구현하기 위한 .NET 클래스 중 하나이다.
장점 : 문맥교환(Context Switching)이 발생하지 않아 CPU 부하를 줄일 수 있다.
👉 하지만 한 스레드가 Lock을 오랫동안 소유하고 있다면, 다른 스레드들은 계속해서 무한루프만 돌 것이다 ❗
따라서 임계 영역이 짧거나, 빨리 처리가 가능한 경우에 사용하는 것이 용이하다.
* 상호 배타적 : 어느 한 사건이 일어났을 때, 다른 사건이 발생할 수 없음. 즉, 동시에 일어날 수 없는 사건
스레드 동기화 :각 스레드들이 순차적으로 혹은 제한적으로 접근하도록 하는 것.
💥 SpinLock 구현
1. lock을 다른 스레드가 선점하고 있으면, lock이 풀릴 때까지 무한 루프를 돈다(spin).
2. lock을 선점하고 있는 스레드가 없으면, 해당 lock을 얻고 lock 상태를 변경한다(소유중)
class SpinLock
{
volatile bool _locked = false;
public void Acquire()
{
while (_locked)
{
// 잠김이 풀리기를 기다린다
}
_locked = true;
}
public void Release()
{
_locked = false;
}
}
하지만 다음과 같은 코드는 아래와 같이 제대로 된 값을 출력하지 않는 것을 볼 수 있다.
잘못된 결과값 출력
while문을 도는 상황에서 다른 스레스가 접근 순서를 달리할 수 있어 경쟁 상태가 발생하기 때문이다.
*경쟁 상태(Race Condition) : 프로세스가 어떤 순서로 데이터에 접근하느냐에 따라 결과값이 달라질 수 있는 상황.
둘 이상의 입력이나 조작이 동시에 일어나 의도하지 않은 결과를 가져오는 경우.
🔎 해결 방법
Interlocked 클래스의 Exchange() 혹은 CompareExchange() 메소드를 통해 이를 해결할 수 있다.
📌 Interlocked.Exchange(ref location, value) 메소드
location 변수를 value 값으로 초기화 하고, 초기화 되기 전의 값(원래의 값)을 리턴한다.
1. _locked를 1로 계속 초기화 하며 초기화 이전 값을 original에 할당하며 이 값을 계속 확인한다.
2. original이 1이면 lock 이 걸려있다는 의미로 계속 반복문을 돌면서 확인하고, original이 0이면 lock이 풀 려 있다는 의미로 반복문을 나와 진입한다.
class SpinLock
{
volatile int _locked = 0;
public void Acquire()
{
while (true)
{
int original = Interlocked.Exchange(ref _locked, 1); //스택에 들어 있는 값
if (original == 0)
break;
}
}
public void Release()
{
_locked = 0;
}
}
Enter과 Exit로 구현하며 Enter는 문을 잠그는 행위, Exit는 문을 여는 행위라 생각하면 된다.
Thread 1에서 Monitor.Enter(_obj)를 통해 임계 영역(Critical Section)에 들어가면,
Thread2는 Thread 1에서 Monitor.Exit(obj)로 해제할 때 까지 해당 영역에 접근하지 못한다.
*임계 영역 : 여러 스레드가 공유 자원에 접근할 때, 하나만 접근할 수 있도록 보장해 주는 영역.
static int number =0; //공유 자원 static object _obj = new object(); //좌물쇠 역할static void Thread_1()
{
for (int i =0; i <100000; i++)
{
/*상호배체 Mutual Exclusive */Monitor.Enter(_obj); //문을 잠그는 행위 -> 다른 이 들어올 수 없음
number++;
Monitor.Exit(_obj); //문을 다시 엶 -> 다른 이 접근 가능
}
}
static void Thread_2()
{
for (int i =0; i <100000; i++)
{
Monitor.Enter(_obj);
number--;
Monitor.Exit(_obj);
}
}
static void Main(string[] args)
{
Task t1 = new Task(Thread_1);
Task t2 = new Task(Thread_2);
t1.Start();
t2.Start();
Task.WaitAll(t1, t2);
Console.WriteLine(number);
}
}
만약, Moniter.Exit를 통해 문을 열지 않고 나가버리면 어떤 상황이 발생할까..
👉 데드락(DeadLock)이 발생한다.
📌 DeadLock이란?
무한히 다음 자원을 기다리는 상태.
상대방의 작업이 끝나기 만을 기다리고 있는 상태로 결과적으로 아무것도 완료되지 못하는 상태이다.
static int number =0; //공유 자원 static object _obj = new object(); //좌물쇠 역할static void Thread_1()
{
for (int i =0; i <100000; i++)
{
/*상호배체 Mutual Exclusive */Monitor.Enter(_obj);
{
number++;
return; //문을 열지 않고 그냥 빠져나감
}
Monitor.Exit(_obj);
}
}
//무한 대기 상태로 DeadLock이 발생함.static void Thread_2()
{
for (int i =0; i <100000; i++)
{
Monitor.Enter(_obj);
number--;
Monitor.Exit(_obj);
}
}
위와 같이 return을 해버리면 Exit로 빠져나오지 못하고 계속 잠겨있는 상태가 된다.
그러면 Thread 2는 열리기만을 기다리는 상태로 무한 대기에 빠져 DeadLock이 발생한 것이다.
