[완료] 수시로 바뀌는 파일 디스크립터를 정확하게 쓰레드로 넘기는 방법

struct completion {
        int done;
        pthread_mutex_t wait;
        pthread_cond_t cond;
};
 
static void init_completion(struct completion *completion)
{
        completion->done = 0;
        pthread_mutex_init(&completion->wait, NULL);
        pthread_cond_init(&completion->cond, NULL);
}
 
static void destroy_completion(struct completion *completion)
{
        pthread_mutex_destroy(&completion->wait);
        pthread_cond_destroy(&completion->cond);
}
 
static void wait_for_completion(struct completion *completion)
{
        pthread_mutex_lock(&completion->wait);
        if (!completion->done) {
                pthread_cond_wait(&completion->cond, &completion->wait);
        }
        completion->done = 0; 
        pthread_mutex_unlock(&completion->wait);
}
 
static void complete(struct completion *completion)
{
        pthread_mutex_lock(&completion->wait);
        completion->done = 1;
        pthread_cond_signal(&completion->cond);
        pthread_mutex_unlock(&completion->wait);
}

#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
 
#include "completion.h"
 
struct my_thread_info {
        int count;
        pthread_mutex_t count_mutex;
        struct completion arg_catch;
};
 
static void thread_cleanup(void *arg)
{
        struct my_thread_info *ti = arg;
        int i;
 
        pthread_mutex_lock(&ti->count_mutex);
        i = ti->count;
        ti->count--;
        pthread_mutex_unlock(&ti->count_mutex);
 
        printf("terminating %d\n", i);
        fflush(stdout);
}
 
static void *thread_proc(void *arg)
{
        struct my_thread_info *ti = arg;
        int i;
 
        pthread_mutex_lock(&ti->count_mutex);
        i = ti->count;
        pthread_mutex_unlock(&ti->count_mutex);
 
        complete(&ti->arg_catch);
 
        pthread_cleanup_push(thread_cleanup, ti);
 
        printf("processing %d\n", i);
        fflush(stdout);
 
        sleep(2);
 
        pthread_cleanup_pop(1);
 
        return (void*)NULL;
}
 
int main()
{
        struct my_thread_info ti;
        pthread_t tmp_tid;
        int ret;
        int i;
 
        ti.count = 0;
        pthread_mutex_init(&ti.count_mutex, NULL);
 
        init_completion(&ti.arg_catch);
 
        for (i = 1; i < 10; i++) {
                pthread_mutex_lock(&ti.count_mutex);
                ti.count = i;
                pthread_mutex_unlock(&ti.count_mutex);
 
                ret = pthread_create(&tmp_tid, NULL, thread_proc, &ti);
                if (ret < 0) {
                        perror("pthread_create()");
                        break;
                }
 
                wait_for_completion(&ti.arg_catch);
 
                pthread_detach(tmp_tid);
        }
 
        do {
                sleep(1);
                pthread_mutex_lock(&ti.count_mutex);
                i = ti.count;
                pthread_mutex_unlock(&ti.count_mutex);
        } while (i != 0);
 
        destroy_completion(&ti.arg_catch);
 
        pthread_mutex_destroy(&ti.count_mutex);
 
        return 0;
}