phread_con_wait和pthread_mutex_lock实现的生产者消费者模型

  1 #include<pthread.h>
  2 #include<unistd.h>
  3 #include<stdio.h>
  4 #include<string.h>
  5 #include<stdlib.h>
  6 
  7 static pthread_mutex_t mtx = PTHREAD_MUTEX_INITIALIZER;
  8 static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
  9 
 10 struct node
 11 {
 12     int n_number;
 13     struct node*n_next;
 14 }*head = NULL;/*[thread_func]*/
 15 
 16 /*释放节点内存*/
 17 static void cleanup_handler(void*arg)
 18 {
 19     printf("Cleanup handler of second thread.\n");
 20 
 21     struct node *p = *((struct node**)arg);
 22     while(p)
 23     {
 24         struct node* tmp = p->n_next;
 25         free(p);
 26         printf("free %p\n", p);
 27         p = tmp;
 28     }
 29 
 30     *((struct node **)arg) = NULL;
 31 
 32     (void)pthread_mutex_unlock(&mtx);
 33 }
 34 
 35 static void* thread_func(void*arg)
 36 {
 37     struct node* p = NULL;
 38     pthread_cleanup_push(cleanup_handler, &head);
 39 
 40     while(1)
 41     {
 42         pthread_mutex_lock(&mtx);
 43         //这个mutex_lock主要是用来保护wait等待临界时期的情况，
 44         //当在wait为放入队列时，这时，已经存在Head条件等待激活
 45         //的条件，此时可能会漏掉这种处理
 46         //这个while要特别说明一下，单个pthread_cond_wait功能很完善，
 47         //为何这里要有一个while(head==NULL)呢？因为pthread_cond_wait
 48         //里的线程可能会被意外唤醒，如果这个时候head!=NULL，
 49         //则不是我们想要的情况。这个时候，
 50         //应该让线程继续进入pthread_cond_wait
 51 
 52         while(1)
 53         {
 54             while(head==NULL)
 55             {
 56                 pthread_cond_wait(&cond,&mtx);
 57             }
 58             //pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，
 59             //然后阻塞在等待队列里休眠，直到再次被唤醒
 60             //（大多数情况下是等待的条件成立而被唤醒，唤醒后，
 61             //该进程会先锁定先pthread_mutex_lock(&mtx);，
 62             //再读取资源用这个流程是比较清楚的
 63             /*block-->unlock-->wait()return-->lock*/
 64 
 65             p = head;
 66             head = head->n_next;
 67             printf("Got %d from front of queue\n",p->n_number);
 68             free(p);
 69         }
 70         pthread_mutex_unlock(&mtx);//临界区数据操作完毕，释放互斥锁
 71 
 72     }
 73 
 74     pthread_cleanup_pop(0);
 75 
 76     return 0;
 77 }
 78 
 79 int main(void)
 80 {
 81     pthread_t tid;
 82     int i;
 83     struct node* p;
 84     pthread_create(&tid,NULL,thread_func,NULL);
 85     //子线程会一直等待资源，类似生产者和消费者，
 86     //但是这里的消费者可以是多个消费者，
 87     //而不仅仅支持普通的单个消费者，这个模型虽然简单，
 88     //但是很强大
 89     for(i=0;i<10;i++)
 90     {
 91         p=(struct node*)malloc(sizeof(struct node));
 92         p->n_number=i;
 93         pthread_mutex_lock(&mtx);//需要操作head这个临界资源，先加锁，
 94         p->n_next=head;
 95         head=p;
 96         pthread_cond_signal(&cond);
 97         pthread_mutex_unlock(&mtx);//解锁
 98         sleep(1);
 99     }
100 
101     p=(struct node*)malloc(sizeof(struct node));
102     p->n_number=i;
103     pthread_mutex_lock(&mtx);//需要操作head这个临界资源，先加锁，
104     p->n_next=head;
105     head=p;
106     pthread_mutex_unlock(&mtx);//解锁
107 
108     printf("thread1 wanna end the cancel thread2.\n");
109     pthread_cancel(tid);
110     //关于pthread_cancel，有一点额外的说明，它是从外部终止子线程，
111     //子线程会在最近的取消点，退出线程，而在我们的代码里，最近的
112     //取消点肯定就是pthread_cond_wait()了。
113     pthread_join(tid,NULL);
114 
115     printf("All done--exiting\n");
116 
117     return 0;
118 }