pthread 에서 pthread_cond_signal() 이 먹통이 되어 버리는

쓰레드 풀을 짜보고 있습니다. C++ 쓰레드 콜백 함수만 빼고 나머지는 하나의 클래스로 만들었습니다.

객체를 생성할때 쓰레드의 갯수를 입력받아 malloc로 공간을 할당하고 stat 에 값을 넣어 동작중인지 아닌지를 판단해서 run() 함수가 실행할때 앞쪽부터 검사하는 방법을 사용하고 있습니다.

문제는 pthread_cond_wait() 된 쓰레드들중에 0번 쓰레드를 제외한 나머지 쓰레드는 pthread_cond_signal() 으로 깨어나질 못한다는데 있습니다.

골치 아프네요. 이것저것 모아서 거의다 되어가는데 결정적인 문제가 :cry:

아래 코드는 하나의 파일로 묶은 것이고 바로 컴파일 될껍니다. 실행코드까지 넣었으니 테스트 부탁 드립니다.

아참 참고로 FreeBSD환경에서 -pthread로 컴파일 해서 작업중입니다.

#include <pthread.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

#define THREAD_DATA_SIZE 256
#define THREAD_ENABLE    0
#define THREAD_DISABLE   1

void*
threadPool(void *data);

typedef struct _thr_info
{
    pthread_t           *thread;
    pthread_mutex_t     *mutex;
    pthread_cond_t      *cond;
    char                *data;
    int                 stat;
    int                 serial;
} thr_info;

class ThreadPool
{
    public:
        ThreadPool(int);
        ~ThreadPool();
        int             init();
        int             run(char *);

    private:

        int             thr_size;       // 쓰래드 갯수
        thr_info        *thrque;
        void initThrInfo(thr_info&, int);
        void freeThrInfo(thr_info &);
};


// 생성자에 생성할 쓰레드 풀의 갯수를 인자로 넣는다.
ThreadPool::ThreadPool(int thread_size)
{
    thr_size    = thread_size;
    thrque      = NULL;
}


ThreadPool::~ThreadPool()
{
    for(int i=0; i<thr_size; ++i)
    {
        freeThrInfo(thrque[i]);
    }
    free(thrque);
}


// 쓰레드 자원을 할당한다.
int
ThreadPool::init()
{
    // 메모리를 할당 한다.
    thrque  = (thr_info*)     malloc(sizeof(thr_info)*thr_size);
    if(thrque == NULL)
    {
        return -1;
    }

    for(int i=0; i<thr_size; ++i)
    {
        initThrInfo(thrque[i], i);
    }
    return 0;
}

// 외부에서 쓰레드에게 데이터를 전달하고 쓰레드 동작을 
// 시키는 함수
int
ThreadPool::run(char *data)
{
    thr_info *thr;
    char buf[1024];
    strncpy(buf, data, 1023);
    while(1)
    {
        for(int i=0; i<thr_size; ++i)
        {
            thr = &(thrque[i]);
            if(thr->stat == THREAD_ENABLE)
            {
                printf("RUN : get sleep thread #%d\n", thr->serial);
                pthread_mutex_unlock(thr->mutex);
                pthread_mutex_lock(thr->mutex);
                thr->stat = THREAD_DISABLE;
                strncpy(thr->data, data, THREAD_DATA_SIZE-1);
                printf("( %d : %d : %d )\n", thr->serial, thr->mutex, thr->cond);
                pthread_mutex_unlock(thr->mutex);
                pthread_cond_signal(thr->cond);
                return 0;
            }
        }
        usleep(10000);
    }
}

// 실제 동작되는 프로세스
void
ThreadPool::initThrInfo(thr_info &thri, int pos)
{
    thri.thread     = NULL;
    thri.thread     = NULL;
    thri.mutex      = NULL;
    thri.cond       = NULL;
    thri.data       = NULL;

    thri.thread     = (pthread_t*)          malloc(sizeof(pthread_t));
    thri.mutex      = (pthread_mutex_t*)    malloc(sizeof(pthread_mutex_t));
    thri.cond       = (pthread_cond_t*)     malloc(sizeof(pthread_cond_t));
    thri.data       = (char *)              calloc(sizeof(char)*THREAD_DATA_SIZE, 0x00);
    thri.serial     = pos;

    pthread_mutex_init(thri.mutex, NULL);
    pthread_cond_init(thri.cond, NULL);
    printf("( %d : %d : %d )\n", thri.serial, thri.mutex, thri.cond);
    pthread_create(thri.thread, NULL, &threadPool, (void *)&thri);
}

// 자원을 thr_info 내부에 할당된 자원을 free한다.
void
ThreadPool::freeThrInfo(thr_info &thri)
{
    if(thri.thread != NULL) free(thri.thread);
    if(thri.mutex  != NULL) free(thri.mutex);
    if(thri.cond   != NULL) free(thri.cond);
    if(thri.data   != NULL) free(thri.data);
}


void*
threadPool(void *data)
{
    thr_info *thr = (thr_info*)data;
    while(1)
    {
        thr->stat = THREAD_ENABLE;
        pthread_mutex_lock(thr->mutex);
        pthread_cond_wait(thr->cond, thr->mutex); // 0번 쓰레드를 제외한     
        pthread_mutex_unlock(thr->mutex)              // 다른 스레드들은 모두 이곳에서 block 되어
                                                  // 깨어나지 못합니다. 


        ////////////////////////////////////////////////
        // 실제 필요한 동작이 들어가는 부분..
        ////////////////////////////////////////////////

        // 동작이 요청보다 느리게 하기 위해서 sleep
        sleep(2);                                       

        // 받아온 데이터를 출력
        // serial에는 쓰레드 번호가 들어가 있다.

        printf("#%d : data : %s \n",thr->serial, thr->data); fflush(stdout);
        ////////////////////////////////////////////////
    }
}



int main()
{
    char buf[1024];
    ThreadPool tp(3);       // 3개의 쓰레드를 가지는 pool을 생성.
    sleep(1);
    tp.init();
    sleep(1);
    for(int i =0; i< 1000; ++i)
    {
        sprintf(buf, "#%d", i);
        tp.run(buf);         // 쓰레드를 동작
        sleep(1);            // 1초 간격으로 처리를 요청한다.  
    }

    return 0;
}