多线程同步

std::deque<std::string> task_queue;
pthread_mutex_t g_mutex;
pthread_cond_t  g_cond;

FILE* g_fp = NULL;
pthread_mutex_t g_fp_mutex;

bool g_stop = false;
bool g_read_th_run = true;
bool g_proc_th_run1 = true;
bool g_proc_th_run2 = true;
bool g_proc_th_run3 = true;
bool g_proc_th_run4 = true;

void* read_func(void* obj);
void* proc_func(void* obj);
void  cleanup_handler(void* obj);
void int_handler(int no)
{
    fprintf(stdout, "Bye!\n");
    g_stop = true;
}

void* read_func(void* obj)
{
    pthread_detach(pthread_self());

    //pthread_cleanup_push(cleanup_handler, NULL);

    const char* file = (const char*)(obj);
    FILE* fp = fopen(file, "r");
    if (!fp) return NULL;

    char* line = new char [1024];
    size_t len = 1024;
    while (!feof(fp))
    {
        getline(&line, &len, fp);

        if (len)
        {
            pthread_mutex_lock(&g_mutex);
            task_queue.push_back(line);
            pthread_cond_signal(&g_cond);
            pthread_mutex_unlock(&g_mutex);
            memset(line, 0, 1024);
        }
    };

    fprintf(stdout, "read thread quit!\n");

    free(line);
    fclose(fp);
    return NULL;
}

void* proc_func(void* obj)
{
    //pthread_cleanup_push(cleanup_handler, NULL);

    bool& running = *(bool*)(obj);
    while (running)
    {
        pthread_mutex_lock(&g_mutex);
        if (task_queue.empty())
        {
            pthread_cond_wait(&g_cond, &g_mutex);
        }

        if (task_queue.size())
        {
            pthread_mutex_lock(&g_fp_mutex);
            std::string& s = task_queue.front();
            fwrite(s.c_str(), s.size(), 1, g_fp);
            task_queue.pop_front();
            pthread_mutex_unlock(&g_fp_mutex);
        }

        pthread_mutex_unlock(&g_mutex);
    }

    fprintf(stdout, "proc thread quit!\n");

    return NULL;
}

void  cleanup_handler(void* obj)
{
    fprintf(stdout, "%d: call cleanup_handler\n", (int)pthread_self());
}