问一下pthread条件变量的问题（已解决）

izualzhy

例子代码主要实现producer线程生产（添加元素到链表），consumer线程消费（取出元素从链表）。按理说是LIFO才对，不过执行多次程序时有时会出现不符合LIFO的情况（都是在刚开始时出现）。
我仔细检查了下代码，应该是对的。与signal的位置没有关系。
结果有时是这样的：
Produce 160
Produce 93
Consume 160

谢谢！

1. #include <stdlib.h>
   
2. #include <pthread.h>
   
3. #include <stdio.h>
   
4. 
   
5. struct msg {
   
6.         struct msg *next;
   
7.         int num;
   
8. };
   
9. 
   
10. volatile struct msg *head;
    
11. pthread_cond_t hasProduct = PTHREAD_COND_INITIALIZER;
    
12. pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
    
13. 
    
14. void *consumer(void *p)
    
15. {
    
16.         struct msg *mp;
    
17.         for(;;) {
    
18.                 /*printf("consumer before lock......\n");*/
    
19.                 pthread_mutex_lock(&lock);
    
20.                 /*printf("consumer get locked : 0x%x\n",head);*/
    
21.                 while (head==NULL) {
    
22.                 /*if (head==NULL) {*/
    
23.                 //条件受互斥锁保护?
    
24.                 //用while不用if?
    
25.                         printf("consumer entering wait......\n");
    
26.                         pthread_cond_wait(&hasProduct,&lock);
    
27.                         printf("consumer leaveing wait : %d......\n",head->num);
    
28.                 }
    
29.                 mp = head;
    
30.                 head = mp->next;
    
31.                 pthread_mutex_unlock(&lock);
    
32.                 printf("Consume %d\n",mp->num);
    
33.                 /*printf("Consume 0x%x,%d,0x%x\n", mp,mp->num,head);*/
    
34.                 free(mp);
    
35.                 sleep(rand()%5);
    
36.         }
    
37. }
    
38. 
    
39. void *producer(void *p)
    
40. {
    
41.         /*printf("producer starting......\n");*/
    
42.         struct msg *mp;
    
43.         for(;;) {
    
44.                 mp = malloc(sizeof(struct msg));
    
45.                 mp->num = rand()%1000 + 1;
    
46.                 /*printf("producer before lock......\n");*/
    
47.                 pthread_mutex_lock(&lock);
    
48.                 mp->next = head;
    
49.                 head = mp;
    
50.                 printf("Produce %d\n",mp->num);
    
51.                 pthread_mutex_unlock(&lock);
    
52.                 /*printf("producer before signal......\n");*/
    
53.                 pthread_cond_signal(&hasProduct);
    
54.                 //signal与lock位置无关
    
55.                 sleep(rand()%5);
    
56.         }
    
57. }
    
58. 
    
59. int main(int argc, char *argv[])
    
60. {
    
61.         pthread_t pid,cid;
    
62.         srand(time(NULL));
    
63.         pthread_create(&pid,NULL, producer, NULL);
    
64.         pthread_create(&cid,NULL, consumer, NULL);
    
65. 
    
66.         pthread_join(pid,NULL);
    
67.         pthread_join(cid,NULL);
    
68. 
    
69.         struct msg* mp = head;
    
70.         while (head!=NULL) {
    
71.                 mp = head;
    
72.                 head = head->next;
    
73.                 printf("main thread: %d\n",mp->num);
    
74.                 free(mp);
    
75.         }
    
76.         return 0;
    
77. }

复制代码

digdeep126

回复 1# izualzhy


    很简单，你将 pthread_mutex_unlock(&lock);和printf("Consume %d\n",mp->num);两者的位置条换一下就不会出现这样的问题了。
出现你所说的原因是：消费者的打印语句printf("Consume %d\n",mp->num);因为没有在锁中，所以消费第一个“产品”的打印语句是可能发生在第二个“产品”已经产生的后面的。但这是并不与“LIFO”相矛盾！

izualzhy

回复 2# digdeep126


    看了下的确是，只顾去关注互斥量啊什么的位置了，谢谢。