처음엔 괜찮은데 2번째부터 한 방향만 계속 락을 안 놔줘 -_-;
락을 제대로 놓게 설정은 했는데...왜그러는지 좀 봐줄 수 있겠어?

메인함수는 그냥 초기화값만 설정하구 스레드 만들고 기다리니까 생략했구,
실질적으로는 요 함수가 기능을 하는데...

일단 락 안 걸린 놈들은 잘 실행하고
락을 돌려주는게 문제인 거 같은데, 뭐가 문제인지 모르겠네;

#include "hmonitor.h"

// 스레드 초기화

void thr_init(thr_arg *data, int direct[], pthread_mutex_t *des, pthread_cond_t **cptr)
{
 int  i;
 data->passed = 0;
 data->wait_time = (int **)malloc(sizeof(int)*MAXTIME);
 data->resource[0] = &direct[0];
 data->resource[1] = &direct[1];
 data->resource[2] = &direct[2];
 data->resource[3] = &direct[3];
 data->mutex = des;
 data->condptr = cptr;

 for(i=0; i<MAXTIME; i++)
 {
  data->wait_time[i] = (int *)malloc(sizeof(int));
  *(data->wait_time[i]) = 0;
 }
}

// 동쪽으로 가는 방향의 스레드 관리

void *eastbound(void *data)
{
 thr_arg  *east = (thr_arg *)data;
 int  timecount=0;
 
 while(timecount!=MAXTIME)
 {
//진입 시도
  eastbound_enter(east);
// 성공시 1초 대기
  timecount++;
  sleep(1);
//탈출
  eastbound_exit(east);
 }
}

void eastbound_enter(thr_arg *eptr)
{
// 이 놈은 3번과 0번을 가져야 함.
 static int passed=0;
 int  flag=1;

 pthread_mutex_lock(eptr->mutex);
 while(flag){
  flag=0;
// 3번 방향이 비어있으면
  if(*(eptr->resource[3]) == FREE)
  {
//차지하되
   *(eptr->resource[3]) = EAST;
  }
  else
  {
// 그렇지 않으면
   puts("[EASTBOUND] Waiting D Section");
   if(*(eptr->resource[0]) == EAST)
   {
// 0번을 갖고 있는 경우 돌려준다.
    *(eptr->resource[0]) = FREE;
   }
   pthread_cond_wait(eptr->condptr[3], eptr->mutex);
   flag=1;
   continue;
  }
// 0번을 갖되
  if(*(eptr->resource[0]) == FREE)
  {
   *(eptr->resource[0]) = EAST;
  }
  else
  {
// 갖지 못하면
   puts("[EASTBOUND] Waiting A Section");
// 3번도 마저 돌려준다.
   if(*(eptr->resource[3]) == EAST)
   {
    *(eptr->resource[3]) = FREE;
   }
   pthread_cond_wait(eptr->condptr[0], eptr->mutex);
   flag=1;
   continue;
  }
 }
 printf("[EASTBOUND] %dth car is now passing!\\n", ++passed);
 pthread_mutex_unlock(eptr->mutex);
}

void eastbound_exit(thr_arg *eptr)
{
 pthread_mutex_lock(eptr->mutex);
// 갖고 있던걸 놔 준다.
 *(eptr->resource[3]) = FREE;
 *(eptr->resource[0]) = FREE;
 pthread_mutex_unlock(eptr->mutex);
 pthread_cond_broadcast(eptr->condptr[3]);
 pthread_cond_broadcast(eptr->condptr[0]);
}

void westbound_enter(thr_arg *wptr)
{
//1번, 2번을 가져야 함.
 static int passed=0;
 int  flag=1;
 pthread_mutex_lock(wptr->mutex);
 while(flag)
 {
  flag=0;
  if(*(wptr->resource[1]) == FREE)
  {
   *(wptr->resource[1]) = WEST;
  }
  else
  {
   puts("[WESTBOUND] Waiting B Section");
   if(*(wptr->resource[2]) == WEST)
   {
    *(wptr->resource[2]) = FREE;
   }
   pthread_cond_wait(wptr->condptr[1], wptr->mutex);
   flag=1;
   continue;
  }
  if(*(wptr->resource[2]) == FREE)
  {
   *(wptr->resource[2]) = WEST;
  }
  else
  {
   puts("[WESTBOUND] Waiting C Section");
   if(*(wptr->resource[1]) == WEST)
   {
    *(wptr->resource[1]) = FREE;
   }
   pthread_cond_wait(wptr->condptr[2], wptr->mutex);
   flag=1;
   continue;
  }
 }
 printf("[WESTBOUND] %dth car is now passing!\\n", ++passed);
 pthread_mutex_unlock(wptr->mutex);
}

void westbound_exit(thr_arg *wptr)
{
 pthread_mutex_lock(wptr->mutex);
 *(wptr->resource[1]) = FREE;
 *(wptr->resource[2]) = FREE;
 pthread_mutex_unlock(wptr->mutex);
 pthread_cond_broadcast(wptr->condptr[1]);
 pthread_cond_broadcast(wptr->condptr[2]);
}

void *westbound(void *data)
{
        thr_arg         *west = (thr_arg *)data;
        int             timecount = 0;

 while(timecount!=MAXTIME)
 { 
  westbound_enter(west);
  timecount++;
  sleep(1);
  westbound_exit(west);
 }
}

void southbound_enter(thr_arg *sptr)
{
// 남쪽 방향으로 가며
// 2번 3번을 가져야 한다
 static int      passed=0;
 int             flag=1;
 pthread_mutex_lock(sptr->mutex);
 while(flag)
 {
  flag=0;
  printf("[SOUTHBOUND] : Before wait, C Section Number : %d\\n", *(sptr->resource[2]));
  printf("%d\\n", *(sptr->resource[2]));
  printf("%d\\n", *(sptr->resource[2]));
  if(*(sptr->resource[2]) == FREE)
  {
   *(sptr->resource[2]) = SOUTH;
  }
  else
  {
   puts("[SOUTHBOUND] Waiting C Section");
   if(*(sptr->resource[3]) == SOUTH)
   {
    *(sptr->resource[3]) = FREE;
   }
   pthread_cond_wait(sptr->condptr[2], sptr->mutex);
   printf("[SOUTHBOUND] Wake up, current C Section Number : %d\\n", *(sptr->resource[2]));
   flag=1;
   continue;
  }
  if(*(sptr->resource[3]) == FREE)
  {
   *(sptr->resource[3]) = SOUTH;
  }
  else
  {
   puts("[SOUTHBOUND] Waiting D Section");
   if(*(sptr->resource[2]) == SOUTH)
   {
    *(sptr->resource[2]) = FREE;
   } 
   pthread_cond_wait(sptr->condptr[3], sptr->mutex);
   flag=1;
   continue;
  }
 }
 printf("[SOUTHBOUND] %dth car is now passing!\\n", ++passed);
 pthread_mutex_unlock(sptr->mutex);
}

void southbound_exit(thr_arg *sptr)
{
         pthread_mutex_lock(sptr->mutex);
  *(sptr->resource[2]) = FREE;
  *(sptr->resource[3]) = FREE;
  pthread_mutex_unlock(sptr->mutex);
  pthread_cond_broadcast(sptr->condptr[2]);
  pthread_cond_broadcast(sptr->condptr[3]);
}

void *southbound(void *data)
{
 thr_arg         *south = (thr_arg *)data;
 int             timecount = 0;

 while(timecount!=MAXTIME)
 {
  southbound_enter(south);
  timecount++;
  sleep(1);
  southbound_exit(south);
 }
}

void northbound_enter(thr_arg *nptr)
{
//북쪽 방향으로 가야하며
//0번 1번을 가져야 한다.
         static int      passed=0;
  int             flag=1;
  pthread_mutex_lock(nptr->mutex);
  while(flag)
  {
   flag=0;
   if(*(nptr->resource[0]) == FREE)
   {
    *(nptr->resource[0]) = NORTH;
   }
   else
   {
    puts("[NORTHBOUND] Waiting A Section");
    if(*(nptr->resource[1]) == NORTH)
    {
     *(nptr->resource[1]) = FREE;
    }
    pthread_cond_wait(nptr->condptr[0], nptr->mutex);
    puts("[NORTHBOUND] --Debug : Condition Wake up");
    flag=1;
    continue;
   }
   if(*(nptr->resource[1]) == FREE)
   {
    *(nptr->resource[1]) = NORTH;
   }
   else
   {
    puts("[NORTHBOUND] Waiting B Section");
    if(*(nptr->resource[0]) == NORTH)
    {
     *(nptr->resource[0]) = FREE;
    }
    pthread_cond_wait(nptr->condptr[1], nptr->mutex);
    flag=1;
    continue;
   }
  }
  printf("[NORTHBOUND] %dth car is now passing!\\n", ++passed);
  pthread_mutex_unlock(nptr->mutex);
}

void northbound_exit(thr_arg *nptr)
{
 pthread_mutex_lock(nptr->mutex);
 *(nptr->resource[0]) = FREE;
 *(nptr->resource[1]) = FREE;
 pthread_mutex_unlock(nptr->mutex);
 pthread_cond_broadcast(nptr->condptr[0]);
 pthread_cond_broadcast(nptr->condptr[1]);
}

void *northbound(void *data)
{
 thr_arg         *north = (thr_arg *)data;
 int             timecount = 0;

 while(timecount!=MAXTIME)
 {
  northbound_enter(north);
  timecount++;
  sleep(1);
  northbound_exit(north);
 }
}