POSIX 学习笔记---工作流

POSIX 工作流 ：

每个线程反复的在数据系列集上执行同一种操作，并把操作结果传递给下一步骤的其他线程。

每个线程由 stage_t 描述：

一个互斥量 m_mutex

两个条件变量：

m_ready_cond：表示当前的线程准备好处理新数据

m_available_cond：表示通知下一步数据已经可用

整个流水线由 pipe_t 描述，构造了一个流水线的队列。

handle_message 和 send 方法是线程的核心用来处理当前的消息和向下一步处理发送数据。

#include <pthread.h>#include <stdlib.h>#include <stdio.h>typedef struct _stage_t{    pthread_t        m_tid;    int              m_tIdx;    pthread_mutex_t  m_mutex;    pthread_cond_t   m_ready_cond;    pthread_cond_t   m_available_cond;        int              m_ready;    int              m_act;    char             m_data[80];    struct _stage_t* m_next;} stage_t;typedef struct _pipe_t{    stage_t*        m_head;    stage_t*        m_tail;    int             m_stages;    pthread_mutex_t m_mutex;    int             m_active;} pipe_t;typedef struct _msg_struct{    int    m_msgID;    int    m_value;    char   m_buff[64];} msg_t;void send(stage_t* pStage, char *pData, int nAct){    if ((NULL == pStage) || (NULL == pData))        {        return;        }        pthread_mutex_lock(&pStage->m_mutex);    while(pStage->m_ready)    {        pthread_cond_wait(&pStage->m_ready_cond, &pStage->m_mutex);    }        pStage->m_ready = 1;    pStage->m_act = nAct;        memcpy(pStage->m_data, pData, sizeof(msg_t));    pthread_cond_signal(&pStage->m_available_cond);    pthread_mutex_unlock(&pStage->m_mutex);}void* handle_message(void* arg){    stage_t* pStage = NULL;    if (NULL == arg)    {        return;    }        pStage = (stage_t*) arg;    msg_t* pMsg = (msg_t*)&pStage->m_data;        pthread_mutex_lock(&pStage->m_mutex);    while(1)    {        while(pStage->m_ready != 1)        {            pthread_cond_wait(&pStage->m_available_cond, &pStage->m_mutex);            }        printf("tid=%d recv msg: %s\n",               pStage->m_tIdx, pMsg->m_buff);                       pMsg->m_value += 2;        sprintf(pMsg->m_buff, "MsgID=%d, value%d\n", pMsg->m_msgID, pMsg->m_value);                pStage->m_ready = 0;        if (pStage->m_next != NULL)            send(pStage->m_next, (char*)pMsg, pStage->m_act);                    pthread_cond_signal(&pStage->m_ready_cond);    }}void create_pipe(pipe_t* pipe, int size){    int i = 0;    stage_t* pnew = NULL;    stage_t* head = NULL;    stage_t* p    = NULL;        if (NULL == pipe)        return;            pthread_mutex_init(&pipe->m_mutex, NULL);    pipe->m_stages = size;    pipe->m_active = 0;        for (i = 0; i < size; i++)    {        pnew = (stage_t*)malloc(sizeof(stage_t));        pthread_mutex_init(&pnew->m_mutex, NULL);        pthread_cond_init(&pnew->m_ready_cond, NULL);        pthread_cond_init(&pnew->m_available_cond, NULL);        pnew->m_ready = 0;        memset(pnew->m_data, 0, 80);        pnew->m_next = NULL;        pnew->m_tIdx = i;                if (i == 0)        {            head = pnew;            p = pnew;        }        else        {            p->m_next = pnew;            p = p->m_next;        }    }        pipe->m_head = head;    pipe->m_tail = pnew;        for (p = pipe->m_head; p->m_next != NULL; p = p->m_next)    {        pthread_create(&p->m_tid, NULL, handle_message, (void*)p);        }}int pipe_start(pipe_t* p, char* msg, int nAct){    pthread_mutex_lock(&p->m_mutex);    p->m_active++;        pthread_mutex_unlock(&p->m_mutex);        if (NULL == msg)    {        printf("pipe_start: msg is NULL \n");        return 0;    }    send(p->m_head, msg, nAct);}int pipe_result(pipe_t* p){    pthread_mutex_lock(&p->m_tail->m_mutex);        msg_t* stMsg = (msg_t*) p->m_tail->m_data;        if (stMsg == NULL)    {        pthread_mutex_unlock(&p->m_tail->m_mutex);        return 0;    }        while(!p->m_tail->m_ready)    {        pthread_cond_wait(&p->m_tail->m_available_cond,                          &p->m_tail->m_mutex);    }        printf("last tid=%d recv msg=%s\n", p->m_tail->m_tIdx,           stMsg->m_buff);               memset(&p->m_tail->m_data, 0, 80);    p->m_tail->m_ready = 0;    pthread_cond_signal(&p->m_tail->m_ready_cond);    pthread_mutex_unlock(&p->m_tail->m_mutex);        return 0;}int main(){    pipe_t* pWF = NULL;        char buff[32];    int nCnt = 0;    msg_t stMsg;        pWF = (pipe_t*)malloc(sizeof(pipe_t));        pthread_mutex_init(&pWF->m_mutex, NULL);    pWF->m_head = NULL;    pWF->m_tail = NULL;    pWF->m_stages = 0;    pWF->m_active = 0;        create_pipe(pWF, 5);    while(1)    {        sprintf(stMsg.m_buff, "this is Msg %d\n", nCnt);        printf("Pipe Start: %d\n", nCnt);        stMsg.m_value = nCnt;        stMsg.m_msgID = nCnt;        pipe_start(pWF, (char*)&stMsg, nCnt);        nCnt++;        sleep(2);        pipe_result(pWF);    }    return 0;}