深入Phtread(三)：线程的同步-Condition Variables

    继续昨天的线程同步，条件变量（Condition Variables）是用于线程间，通信共享数据状态改变的机制。

1. 简介
2. 条件变量的创建和销毁
3. 等待条件变量
4. 唤醒等待条件变量的线程

简介

    当线程互斥地访问一些共享的状态时，往往会有些线程需要等到这些状态改变后才应该继续执行。如：有一个共享的队列，一个线程往队列里面插入数据，另一个线程从队列中取数据，当队列为空的时候，后者应该等待队列里面有值才能取数据。而共享数据（队列）应该用mutex来保护，为了检查共享数据的状态（队列是否为空），线程必须先锁定mutex，然后检查，最后解锁mutex。

 

    问题出来了：当另外一个线程B锁定mutex后，往队列里面插入了一个值，B并不知道A在等着它往队列里面放入一个值。，线程A（等待状态改变）一直在运行，线程B可能已经检查过队列是空的，并不知道队列里已经有值了，所以一直阻塞着自己。为了解决这样的问题引入了条件变量机制。线程B等待于一个条件变量，当线程A插入了一个值后，signal或broadcast这个条件变量，通知线程B状态已改变，A发现条件变量被signaled了，就继续执行。就这样，当一个线程改变共享数据状态后，可以及时通知那些等待于该状态的线程。图示下：

 

    中间的矩形代表条件变量，当线程线位于矩形内，表示线程等待该条件变量。位于中心线下下方，则表示signal了该条件变量。

    开始线程1 signal 了条件变量，由于没有其他线程等待于该条件变量，所以没什么效果。然后，线程1和线程2先后等待该条件变量，过了一会，线程3 signal了条件变量，线程3的信号解除了线程1的阻塞。然后，线程3等待该条件变量。最后线程1 broadcast了该条件变量，同时解除了等待于条件变量的线程1和线程2。

 

条件变量的创建和销毁

pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

int pthread_cond_init(pthread_cond_t* cond, pthread_condattr_t* condattr);

int pthread_cond_destroy(pthread_cond_t* cond);

 

和互斥量一样，可以动态创建和静态创建。

静态创建：条件变量声明为extern或static变量时。

例程：

[cpp] view plaincopy

1. #include <pthread.h>  
2. #include "error.h"  
3.   
4. typedef struct my_struct_tag  
5. {  
6.     pthread_mutex_t mutex;  
7.     pthread_cond_t cond;  
8.     int value;  
9. } my_struct_t;  
10.   
11. my_struct_t data = {PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};  
12.   
13. int main()  
14. {  
15.     return 0;  
16. }  

 

动态创建：一般情况下，条件变量要和它的判定条件定义在一起，此时若包含该条件变量的数据动态创建了，则条件变量也需要动态创建，不过记得不用时用pthread_cond_destroy销毁。

 

例程：

[cpp] view plaincopy

1. #include <pthread.h>  
2. #include "error.h"  
3.   
4. typedef struct my_struct_tag  
5. {  
6.     pthread_mutex_t mutex;  
7.     pthread_cond_t cond;  
8.     int value;  
9. } my_struct_t;  
10.   
11. int main()  
12. {  
13.     my_struct_t* data;  
14.     data = (my_struct_t*)malloc(sizeof(my_struct_t));  
15.     if(data == NULL)  
16.         ERROR_ABORT(errno,"Allocate structure");  
17.   
18.     int status;  
19.     status = pthread_mutex_init(&data->mutex, NULL);  
20.     if(status != 0)  
21.         ERROR_ABORT(status, "Initial mutex");  
22.     status = pthread_cond_init(&data->cond, NULL);  
23.     if(status != 0)  
24.         ERROR_ABORT(status, "Initial condition");  
25.   
26.     /* .... */  
27.       
28.     status = pthread_cond_destroy(&data->cond);  
29.     if(status != 0)  
30.         ERROR_ABORT(status, "Destroy cond");  
31.     status = pthread_mutex_destroy(&data->mutex);  
32.     if(status != 0)  
33.         ERROR_ABORT(status, "Destroy mutex");  
34.   
35.     free(data);  
36.   
37.     return 0;  
38. }  

 

等待条件变量

int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex);

int pthread_cond_timedwait(pthread_cond_t* cond, pthread_mutex_t* mutex, struct timespec* expiration);

 

    条件变量与互斥量一起使用，调用pthread_cond_wait或pthread_cond_timedwait时，记得在前面锁定mutex，尽可能多的判断判定条件。上面提到的两个等待条件变量的函数，显示解锁mutex，然后阻塞线程等待状态改变，等待的条件变量signaled后，锁定mutex，返回。记着，这两个函数返回时，mutex一定是锁定的。

 

多个条件变量可以共享一个互斥变量，相反则不成立。

 

例程：

[cpp] view plaincopy

1. #include <pthread.h>  
2. #include <time.h>  
3. #include "error.h"  
4. #include <errno.h>  
5.   
6. typedef struct my_struct_tag  
7. {  
8.     pthread_mutex_t mutex;  
9.     pthread_cond_t cond;  
10.     int value;  
11. } my_struct_t;  
12.   
13. my_struct_t data = { PTHREAD_MUTEX_INITIALIZER, PTHREAD_COND_INITIALIZER, 0};  
14.   
15. int hibernation = 1;  
16.   
17. void* wait_thread(void* arg)  
18. {  
19.     int  status;  
20.     sleep(hibernation);  
21.   
22.     status = pthread_mutex_lock(&data.mutex);  
23.     if(status != 0)  
24.         ERROR_ABORT(status, "Lock mutex");  
25.   
26.     data.value = 1;  
27.     status = pthread_cond_signal(&data.cond);  
28.     if(status != 0)  
29.         ERROR_ABORT(status, "Singal cond");  
30.   
31.     status = pthread_mutex_unlock(&data.mutex);  
32.     if(status != 0)  
33.         ERROR_ABORT(status, "Unlock mutex");  
34.   
35.     return NULL;  
36. }  
37.   
38. int main(int argc, char* argv[])  
39. {  
40.     pthread_t tid;  
41.     int status;  
42.     struct timespec timeout;  
43.   
44.     if(argc > 1)  
45.         hibernation = atoi(argv[1]);  
46.   
47.     status = pthread_create(&tid, NULL, wait_thread, NULL);  
48.     if(status != 0)  
49.         ERROR_ABORT(status, "Create wait thread");  
50.   
51.     timeout.tv_sec = time(NULL) + 2;  
52.     timeout.tv_nsec = 0;  
53.   
54.     status = pthread_mutex_lock(&data.mutex);  
55.     if(status != 0)  
56.         ERROR_ABORT(status, "Lock mutex");  
57.   
58.     while(data.value == 0)  
59.     {  
60.         status = pthread_cond_timedwait(&data.cond, &data.mutex, &timeout);  
61.         if(status == ETIMEDOUT)  
62.         {  
63.             printf("Condition wait timed out./n");  
64.             break;  
65.         }else  
66.         if(status != 0)  
67.             ERROR_ABORT(status, "timewait");  
68.     }  
69.   
70.     if(data.value != 0)  
71.         printf("Condition wa signaled!/n");  
72.   
73.     status = pthread_mutex_unlock(&data.mutex);  
74.     if(status != 0)  
75.         ERROR_ABORT(status, "Unlock mutex");  
76. }  

 
 

唤醒等待条件变量的线程

 

int pthread_cond_signal(pthread_cond_t* cond);

int pthread_cond_broadcast(pthread_cond_t* cond);

 

    一但有线程由于某些判定条件（predicate）没满足，等待条件变量。我们就有必要当条件满足时，发送信号去唤醒这些线程。

    注意：broadcast通常很容易被认为是signal的通用版，其实不能这样理解，准确一点应该说，signal是broadcast的优化版。具体区别不大，但signal效率较broadcast高些。但你不确信有几个线程等待条件变量时用broadcast（When in doubt, broadcast!）。

 

例程：

 

[cpp] view plaincopy

1. #include "error.h"  
2. #include <pthread.h>  
3. #include <time.h>  
4. #include <string.h>  
5. #include <errno.h>  
6.   
7. typedef struct alarm_tag  
8. {  
9.     struct alarm_tag* link;  
10.     int seconds;  
11.     time_t time;  
12.     char message[64];  
13. } alarm_t;  
14.   
15. pthread_mutex_t alarm_mutex = PTHREAD_MUTEX_INITIALIZER;  
16. pthread_cond_t alarm_cond = PTHREAD_COND_INITIALIZER;  
17. alarm_t* alarm_list = NULL;  
18. time_t current_alarm = 0;  
19.   
20. /** 
21.  * alarm_mutex need to be locked   
22.  */  
23. void alarm_insert(alarm_t* alarm)  
24. {  
25.     int status;  
26.   
27.     alarm_t* next;  
28.     alarm_t** last;  
29.     last = &alarm_list;  
30.     next = *last;  
31.   
32.     while(next != NULL)  
33.     {  
34.         if(next->time >= alarm->time)  
35.         {  
36.             alarm->link = next;  
37.             *last = alarm;  
38.             break;  
39.         }  
40.   
41.         last = &next->link;  
42.         next = next->link;  
43.     }  
44.   
45.     if(next == NULL){  
46.         *last = alarm;  
47.         alarm->link = NULL;  
48.     }  
49.   
50.     /*for test: output the list*/  
51.     printf("[list: ");  
52.     for(next = alarm_list; next != NULL; next = next->link)  
53.     {  
54.         printf("%d(%d)[/"%s/"]  ", next->time, next->time-time(NULL), next->message);  
55.     }  
56.     printf("]/n");  
57.   
58.     if(current_alarm ==0  || alarm->time < current_alarm)  
59.     {  
60.         current_alarm = alarm->time;  
61.         status = pthread_cond_signal(&alarm_cond);  
62.         if(status != 0)  
63.             ERROR_ABORT(status,"Signal cond");  
64.     }  
65.   
66. }  
67.   
68. void* alarm_thread(void* arg)  
69. {  
70.     alarm_t* alarm;  
71.     int sleep_time;  
72.     time_t now;  
73.     int status, expired;  
74.     struct timespec cond_time;  
75.   
76.     while(1)  
77.     {  
78.         status = pthread_mutex_lock(&alarm_mutex);  
79.         if(status != 0)  
80.             ERROR_ABORT(status, "lock");  
81.   
82.         current_alarm = 0;  
83.   
84.         while(alarm_list == NULL)  
85.         {  
86.             status = pthread_cond_wait(&alarm_cond, &alarm_mutex);  
87.             if(status != 0 )  
88.                 ERROR_ABORT(status, "Wait cond");  
89.         }  
90.   
91.         alarm = alarm_list;  
92.         alarm_list = alarm->link;  
93.         now = time(NULL);  
94.         expired = 0;  
95.   
96.         if(alarm->time > now)  
97.         {  
98.             printf("[wating: %d(%d)/"%s/"]/n", alarm->time, alarm->time - time(NULL), alarm->message);  
99.   
100.             cond_time.tv_sec = alarm->time;  
101.             cond_time.tv_nsec = 0;  
102.             current_alarm = alarm->time;  
103.             while(current_alarm == alarm->time)  
104.             {  
105.                 status = pthread_cond_timedwait(&alarm_cond, &alarm_mutex,&cond_time);  
106.                 if(status == ETIMEDOUT)  
107.                 {  
108.                     expired = 1;  
109.                     break;  
110.                 }  
111.             }  
112.   
113.             if(!expired)  
114.                 alarm_insert(alarm);  
115.         }else  
116.             expired = 1;  
117.   
118.         if(expired)  
119.         {  
120.             printf("(%d) %s/n", alarm->seconds, alarm->message);  
121.             free(alarm);  
122.         }  
123.   
124.         status = pthread_mutex_unlock(&alarm_mutex);  
125.         if(status != 0)  
126.             ERROR_ABORT(status, "Unlock mutex");  
127.     }  
128.   
129.     return 0;  
130. }  
131.   
132. int main()  
133. {  
134.     pthread_t pid;  
135.     int status;  
136.     char line[128];  
137.   
138.     status = pthread_create(&pid, NULL, alarm_thread, NULL);  
139.     if(status != 0)  
140.         ERROR_ABORT(status, "pthread_create");  
141.   
142.     while(1)  
143.     {  
144.         fprintf(stdout, "Alarm>");  
145.         fgets(line, sizeof(line), stdin);  
146.         if(strlen(line) <= 0)  
147.             continue;  
148.   
149.         alarm_t* alarm = (alarm_t*)malloc(sizeof(alarm_t));  
150.         if(alarm == NULL)  
151.             ERROR_ABORT(errno,"memory can't allocated!");  
152.   
153.         if(sscanf(line, "%d %s", &alarm->seconds, alarm->message) != 2)  
154.         {  
155.             printf("Bad Command/n");  
156.             free(alarm);  
157.             continue;  
158.         }  
159.   
160.         status = pthread_mutex_lock(&alarm_mutex);  
161.         if(status != 0)  
162.             ERROR_ABORT(status, "pthread mutex locking..");  
163.   
164.         alarm->time = time(NULL) + alarm->seconds;  
165.   
166.         /* insert into list*/  
167.   
168.         alarm_insert(alarm);  
169.   
170.         status = pthread_mutex_unlock(&alarm_mutex);  
171.         if(status != 0)  
172.             ERROR_ABORT(status, "pthread mutex unlocking...");  
173.     }  
174.   
175.     return 0;  
176. }