构建生产者与消费者的单链表模式

1、在linux环境下实现一个单链表
代码：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<unistd.h>
typedef struct _node{
              int data;
          struct _node *next;
}node_t, *node_p, **node_pp;
static node_p alloc_node(int _d)
{
    node_p _n = (node_p)malloc(sizeof(node_t));
    if (NULL == _n){
      perror("malloc");
      exit(1);
    }
    _n->data = _d;
    _n->next = NULL;
}
static int is_empty(node_p _h)
{
    assert(_h);
    return _h->next == NULL? 1:0;
}
void init_list(node_pp _h)
{
    *_h = alloc_node(0);
}
void delete_node(node_p _tmp)
{
    if (_tmp){
           free(_tmp);
    }
}
void destroy_list(node_p _h)
{
   assert(_h);
   int data;
   while ( !is_empty(_h)){
          pop_list(_h, &data);
   }
   delete_node(_h);
}
void push_list(node_p _h, int _d)
{
    assert(_h);
    node_p _n = alloc_node(_d);
    _n->next = _h->next;
    _h->next = _n;
}
void pop_list(node_p _h, int *_o)
{
    assert(_h);
    assert(_o);
   if (!is_empty(_h)){
             node_p _tmp = _h->next;
        _h->next = _tmp->next;
        *_o = _tmp->data;
        delete_node(_tmp);
   }
}
void show_list(node_p _h)
{
    assert(_h);
    node_p p =  _h->next;
    while (p != NULL){
           printf(" %d ", p->data);
           p = p->next;
    }
    printf("\n");
}
int main()
{
    node_p  head = NULL;
    init_list(&head);
    int i = 0;
        for (; i<10; i++){
               push_list(head, i);
               show_list(head);
               sleep(1);
    }
        int data = 0;
        for (; i>5; i--){
               pop_list(head, &data);
                       show_list(head);
               sleep(1);
        }
    destroy_list(head);
    return 0;
}

运行结果如图所示：

条件变量：函数pthread_cond_init()
pthread_cond_wait()—获得某种资源的执行流的等待的方式
pthread_cond_signal();—唤醒在该条件下等待的执行流
条件变量总是和Mutex搭配使⽤。
⼀个线程可以调⽤用pthread_cond_wait在一个Condition Variable上阻塞等待,这个函数做以下三步操作:
1. 释放Mutex
2. 阻塞等待
3. 当被唤醒时,重新获得Mutex并返回
构建一个生产者与一个消费者模式，创建两个线程在主函数中，代码如下：

    pthread_t id1, id2;
    pthread_create(&id1, NULL, consumer, head);
    pthread_create(&id2, NULL, producter, head);
    pthread_join(id1, NULL);
    pthread_join(id2, NULL);

生产者-消费者,生产者生产⼀一个结构体串在链表的表头上,消费者 从表头取⾛走结构体，代码如下：

static pthread_mutex_t  lock = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t  needproduct = PTHREAD_COND_INITIALIZER;
static void *consumer(void *arg)
{
    node_p h = (node_p)arg;
    for ( ; ; ){
           pthread_mutex_lock(&lock);
           int data = rand()%1234;
           while (! is_empty(h)){

               printf("consumer done...,consumer wait...%d\n", data);
                pthread_cond_wait(&needproduct,&lock);
                printf("consumer wakeup...\n");

       }
     pop_list(h, &data);
     pthread_mutex_unlock(&lock);
    }
}
static void *producter(void *arg)
{
    node_p h = (node_p)arg;
    for( ; ; ){
        pthread_mutex_lock(&lock);
        int data = rand()%1234;
        push_list(h, &data);
        printf("producter done...: %d\n", data);
        sleep(1);
        pthread_mutex_unlock(&lock);
        pthread_cond_signal(&needproduct);
        printf("data is ok, signal consumer!\n");
    }
}  

运行结果：