生產者與消費者：
3,2,1
三種關係：
生產者與消費者：互斥，同步
消費者與消費者：互斥
生產者與生產者：互斥
條件變數：
int pthread_cond_destroy(pthread_cond_t *cond);
int pthread_cond_init(pthread_cond_t *restrict cond,
const pthread_condattr_t *restrict attr);
pthread_cond_t cond = pthread_cond_initializer;
返回值：
成功返回0，失敗返回錯誤號。
堵塞等待：
int pthread_cond_wait(pthread_cond_t *restrict cond,
pthread_mutex_t *restrict mutex);
喚醒：int pthread_cond_broadcast(pthread_cond_t *cond);
int pthread_cond_signal(pthread_cond_t *cond);
乙個condition variable總是和乙個mutex搭配使用的。
乙個執行緒可以呼叫pthread_cond_wait在乙個condition variable上阻塞等待,這個函式做以下三步操作:
1. 釋放mutex
2. 阻塞等待
3. 當被喚醒時,重新獲得mutex並返回
先進後出：
1 #include2 #include3 #include4
5 typedef int _datatype;
6 typedef struct _list
7 list;
11 12
13 pthread_mutex_t mutex = pthread_mutex_initializer;
14 pthread_cond_t cond = pthread_cond_initializer;
15 list* head=null;
16 17
18 list* buy_node()
19 24 void init_list(list** _head)
25 34 *_head=cur;
35 36 }
37 void push_node(list* head,_datatype val)
38 47 else
48
55 }
56 int pop_node(list* head)
57 68 else
69
72 73 }
74 void destroy_list(list* head)
75 84
85 }
86 void show_list(list* _head)
87 94 }
95 void* product(void* arg)
96 108 return null;
109 }
110 void* consumer(void* arg)
111
120 //pthread_mutex_lock(&mutex);
121
122 int val= pop_node(head);
123 sleep(1);
124 printf("consumer:%d\n",val);
125 pthread_mutex_unlock(&mutex);
126 }
127 return null;
128 }
129
130 int main()
131
結果：gcc -o condition condition.c -lpthread
[admin@localhost condition]$ ./condition
product:83
consumer:83
product:86
consumer:86
product:77
consumer:77
product:15
consumer:15
product:93
consumer:93
product:35
consumer:35
product:86
consumer:86
...先進先出：
... 37 void push_node(list* head,_datatype val)
38 49 else
50
55 list* tmp=null;
56 tmp=buy_node();
57 tmp->_val=val;
58 tmp->_next=null;
59 cur->_next=tmp;
60 }
61 }
...101 void* product(void* arg)
102
113 return null;
114 }
115 void* consumer(void* arg)
116
126 //pthread_mutex_lock(&mutex);
127
128 int val= pop_node(head);
129 printf("consumer:%d\n",val);
130 pthread_mutex_unlock(&mutex);
131 }
132 return null;
133 }
結果：[admin@localhost condition]$ ./condition
product:83
product:86
consumer:83
product:77
product:15
product:93
consumer:86
product:35
多消費者多生產者：
...
13 pthread_mutex_t mutex1 = pthread_mutex_initializer;
14 pthread_mutex_t mutex2 = pthread_mutex_initializer;
15 pthread_mutex_t mutex3 = pthread_mutex_initializer;
...104 void* product(void* arg)
105
119 return null;
120 }
121 void* consumer(void* arg)
122
131 //pthread_mutex_lock(&mutex);
132
133 int val= pop_node(head);
134 printf("consumer:tid:%ld,val:%d\n",pthread_self(),val);
135 pthread_mutex_unlock(&mutex1);
136 pthread_mutex_unlock(&mutex3);
137 sleep(1);
138 }
139 return null;
140 }
141
142 int main()
143
169結果：
[admin@localhost condition]$ ./condition
producer:tid:-1227850896,val:83
consumer:tid:-1248830608,val:83
producer:tid:-1217361040,val:86
consumer:tid:-1238340752,val:86
producer:tid:-1227850896,val:77
consumer:tid:-1248830608,val:77
producer:tid:-1217361040,val:15
consumer:tid:-1238340752,val:15
^c 生產者與生產者之間互斥，消費者與消費者之間互斥，各自加個鎖。
生產者消費者模型
1.生產者消費者問題 producer consumer 有限緩衝，多執行緒同步。生產者執行緒和消費者執行緒共享固定大小緩衝區。2.關鍵是保證生產者不會再緩衝區滿時加入資料，消費者不會在緩衝區空時消耗資料。3.解決辦法 讓生產者在緩衝區滿時休眠，等下次消費者消耗緩衝區中的資料的時候，生產者才能被喚醒...
生產者消費者模型
當佇列滿時，生產者需要等待佇列有空間才能繼續往裡面放入商品，而在等待的期間內，生產者必須釋放對臨界資源 即佇列 的占用權。因為生產者如果不釋放對臨界資源的占用權，那麼消費者就無法消費佇列中的商品，就不會讓佇列有空間，那麼生產者就會一直無限等待下去。因此，一般情況下，當佇列滿時，會讓生產者交出對臨界資...
生產者 消費者模型
在寫生產者 消費者模型時，先談及乙個概念 訊號量。sem函式 1 sem init函式是posix訊號量操作中的函式。sem init 初始化乙個定位在 sem 的匿名信號量。value 引數指定訊號量的初始值。pshared 引數指明訊號量是由程序內線程共享，還是由程序之間共享。如果 pshare...