多线程同步

#include <stdio.h>
#include <stdlib.h>
#include <deque>
#include <string>
#include <string.h>
#include <pthread.h>
#include <signal.h>
#include <assert.h>
#include "clock.h"

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;
}

int main(int argc, char* argv[])
{
    if (argc < 2)
    {
        abort();
        return -1;
    }

    signal(SIGINT, int_handler);

    g_fp = fopen("result", "w");

    pthread_mutex_init(&g_fp_mutex, NULL);
    pthread_mutex_init(&g_mutex, NULL);
    pthread_cond_init(&g_cond, NULL);

    pthread_t tid = 0;
    pthread_t tid1 = 0;
    pthread_t tid2 = 0;
    pthread_t tid3 = 0;
    pthread_t tid4 = 0;

    pthread_create(&tid, NULL, read_func, argv[1]);

    pthread_create(&tid1, NULL, proc_func, &g_proc_th_run1);
    pthread_create(&tid2, NULL, proc_func, &g_proc_th_run2);
    pthread_create(&tid3, NULL, proc_func, &g_proc_th_run3);
    pthread_create(&tid4, NULL, proc_func, &g_proc_th_run4);

    while (!g_stop)
    {
        sleep(30);
    };

    g_read_th_run  = false;
    g_proc_th_run1 = false;
    g_proc_th_run2 = false;
    g_proc_th_run3 = false;
    g_proc_th_run4 = false;

    pthread_mutex_lock(&g_mutex);
    pthread_cond_broadcast(&g_cond);
    pthread_mutex_unlock(&g_mutex);

    //assert(!pthread_join(tid, NULL));
    assert(!pthread_join(tid1, NULL));
    assert(!pthread_join(tid2, NULL));
    assert(!pthread_join(tid3, NULL));
    assert(!pthread_join(tid4, NULL));

    fclose(g_fp);

    return 0;
}

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());
}