pthread_mutex_* 와 pthread_cond_*를 사용한 동기화문제

저의 경우 Windows 프로그래밍을 하다가 Linux쪽 프로그래밍을 하다보니
이 문제때문에 골치좀 아팠었습니다.

pthread 이넘... WIN32에 익숙한 프로그래머 입장에서 좀 짜증나죠.

pthread_cond_wait() 이넘의 문제는 wait를 하고 있는 쓰레드가 있다면 깨워지지만 wait를 하고 있는 쓰레드가 없었다면... 아무것도 깨우지 않습니다. -_-;

그리고 WIN32는 쓰레드 핸들, 이벤트 핸들등.. 핸들이라는 이름을 갖는 모든 녀석을 한꺼번에 기다릴 수 있는 WaitForMultipleObjects() 라는 아주 멋진 API도 사용할 수 있지만 pthread는 여러개의 condition 개체를 한꺼번에 기다릴 수 있는 방법도 없고 개체의 종류(thread, condition)에 따라 다른 wait 펑션을 이용해야 합니다.

어째튼.. 해결법은...
이겁니다. 아래를 보시면 아시겠지만...

pthread_mutex_lock(..);
state = TRUE;
pthread_mutex_unlock(..);
pthread_cond_signal(..);

pthread_cond_signal()을 그냥 주시지 말고 state라는 변수를 하나 더 이용해야 합니다.

기다릴때는 state가 FALSE 일때 pthread_cond_wait()를 해 주시면 됩니다.

참고로 제가 사용하는 wait 펑션을 아래에 첨부하겠습니다.
저의 경우 한개의 소스코드로 Windows와 Linux에서 동시에 컴파일 되도록 개발하기때문에 좀 추상화 시켰습니다.

참고로
* wait_sec은 기다릴 시간
* manual_reset는 자동/수동 reset 기능은 갖습니다.

typedef struct
{
#ifdef STHREAD_USE_PTHREAD
	STHREAD_BOOL state;
	STHREAD_BOOL manual_reset;

	pthread_mutex_t mutex;
	pthread_cond_t cond;
#endif

#ifdef STHREAD_USE_WIN32
	HANDLE h_event;
#endif
}scond;

STHREAD_BOOL scond_create(scond* p_cond, STHREAD_BOOL manual_reset)
{
#ifdef STHREAD_USE_PTHREAD
	if(pthread_mutex_init(&(p_cond->mutex), NULL) != 0) return STHREAD_FALSE;

	if(pthread_cond_init(&(p_cond->cond), NULL) != 0)
	{
		pthread_mutex_destroy(&(p_cond->mutex));
		return STHREAD_FALSE;
	}

	p_cond->state = STHREAD_FALSE;
	p_cond->manual_reset = manual_reset;

	return STHREAD_TRUE;
#endif

#ifdef STHREAD_USE_WIN32
	return (p_cond->h_event = CreateEvent(NULL, manual_reset == STHREAD_TRUE ? TRUE : FALSE, FALSE, NULL)) == NULL ? STHREAD_FALSE : STHREAD_TRUE;
#endif
}

STHREAD_BOOL scond_set(scond* p_cond)
{
#ifdef STHREAD_USE_PTHREAD
	pthread_mutex_lock(&(p_cond->mutex));

	p_cond->state = STHREAD_TRUE;

	pthread_mutex_unlock(&(p_cond->mutex));

	pthread_cond_signal(&(p_cond->cond));

	return STHREAD_TRUE;
#endif

#ifdef STHREAD_USE_WIN32
	return SetEvent(p_cond->h_event) == TRUE ? STHREAD_TRUE : STHREAD_FALSE;
#endif
}

STHREAD_BOOL scond_reset(scond* p_cond)
{
#ifdef STHREAD_USE_PTHREAD
	pthread_mutex_lock(&(p_cond->mutex));

	p_cond->state = STHREAD_FALSE;

	pthread_mutex_unlock(&(p_cond->mutex));

	return STHREAD_TRUE;
#endif

#ifdef STHREAD_USE_WIN32
	return ResetEvent(p_cond->h_event) == TRUE ? STHREAD_TRUE : STHREAD_FALSE;
#endif
}

STHREAD_BOOL scond_wait(scond* p_cond, unsigned int wait_sec)
{
#ifdef STHREAD_USE_PTHREAD
	STHREAD_BOOL result;
	struct timeval now;
	struct timespec timeout;
	int retcode;

	pthread_mutex_lock(&(p_cond->mutex));

	switch(wait_sec)
	{
	case 0:
		result = p_cond->state;
		break;

	case STHREAD_INFINITE:
		while(p_cond->state == STHREAD_FALSE)
		{
			pthread_cond_wait(&(p_cond->cond), &(p_cond->mutex));
		}

		result = STHREAD_TRUE;
		break;

	default:
		if(gettimeofday(&now, NULL) == 0)
		{
			timeout.tv_sec = now.tv_sec + wait_sec;
			timeout.tv_nsec = now.tv_usec * 1000;

			retcode = 0;

			while(p_cond->state == STHREAD_FALSE && retcode != ETIMEDOUT)
			{
				retcode = pthread_cond_timedwait(&(p_cond->cond), &(p_cond->mutex), &timeout);
			}

			result = (retcode == ETIMEDOUT) ? STHREAD_FALSE : STHREAD_TRUE;
		}
		else
		{
			result = STHREAD_FALSE;
		}
	}

	if(result == STHREAD_TRUE)
	{
		if(p_cond->manual_reset == STHREAD_TRUE)
		{
			// 수동 리셋으로 설정되어 있다면 다른 wait 펑션이 동작할 수 있도록 해준다.
			pthread_cond_signal(&(p_cond->cond));
		}
		else
		{
			// 자동 리셋으로 설정되어 있다면 상태를 리셋해야 한다.
			p_cond->state = STHREAD_FALSE;
		}
	}

	pthread_mutex_unlock(&(p_cond->mutex));

	return result;
#endif

#ifdef STHREAD_USE_WIN32
	return WaitForSingleObject(p_cond->h_event, wait_sec * 1000) == WAIT_OBJECT_0 ? STHREAD_TRUE : STHREAD_FALSE;
#endif
}