看見一個關於兩個線程交替打印信息的題目，題目大概是

子線程循環 10 次，接著主線程循環 100 次，接著又回到子線程循環 10 次，接著再回到主線程又循環 100 次，如此循環50次，試寫出代碼。

寫了兩個版本，一個是用了mutex，不用條件變量；另外一個是用條件變量。

第一個，不用條件變量

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <pthread.h>
 4 
 5 
 6 
 7 const int LOOP_2 = 2;
 8 const int LOOP_5 = 5
 
;
 9 int loop_count_slave = 10;
10 int loop_count_main = 10;
11 
12 enum bool { FALSE = 0,TRUE =1};
13 enum bool slave_can_print = TRUE;
14 enum bool main_can_print = FALSE;
15 
16 pthread_cond_t cond_slave = PTHREAD_COND_INITIALIZER;
17 pthread_cond_t cond_main =  PTHREAD_COND_INITIALIZER;
18
 
 
19 
20 pthread_mutex_t mutex_slave = PTHREAD_MUTEX_INITIALIZER;
21 pthread_mutex_t mutex_main = PTHREAD_MUTEX_INITIALIZER;
22 
23 void* thread_fun(void* arg);
24 void printf_msg(int type);
25 
26 int main(int argc, char* argv[])
27 {
28     pthread_t tid;
29     int ret;
30     ret = pthread_create(&tid,NULL,thread_fun,NULL);
 
31     if( ret != 0 )
32     {
33         strerror(ret);
34     }
35     while(loop_count_main > 0)
36     {
37         pthread_mutex_lock(&mutex_main);
38         if(main_can_print)
39         {
40             printf_msg(1);
41             loop_count_main -- ;
42             pthread_mutex_lock(&mutex_slave);
43             slave_can_print = TRUE;
44             pthread_mutex_unlock(&mutex_slave);
45             main_can_print = FALSE;
46         }
47         pthread_mutex_unlock(&mutex_main);
48     }
49 
50 
51 }
52 void* thread_fun(void* arg)
53 {
54     while(loop_count_slave > 0)
55     {
56         pthread_mutex_lock(&mutex_slave);
57         if(slave_can_print)
58         {
59             printf_msg(2);
60             loop_count_slave -- ;
61             slave_can_print = FALSE;
62             pthread_mutex_lock(&mutex_main);
63             main_can_print = TRUE;
64             pthread_mutex_unlock(&mutex_main);
65         }
66         pthread_mutex_unlock(&mutex_slave);
67     }
68     return NULL;
69 }
70 void printf_msg(int type)
71 {
72     if(type == 1)
73     {
74         int i = 0;
75         for(; i < LOOP_5; i++)
76         {
77             printf("from master \n");
78 
79         }
80     }
81     else if(type == 2)
82     {
83         int i = 0;
84         for(; i < LOOP_2; i++)
85         {
86             printf("from slave thread\n");
87         }
88     }
89 }

第二個，使用條件變量

 1 #include <stdio.h>
 2 #include <string.h>
 3 #include <pthread.h>
 4 
 5 
 6 
 7 const int LOOP_2 = 2;
 8 const int LOOP_5 = 5;
 9 int loop_count_slave = 10;
10 int loop_count_main = 10;
11 
12 enum bool { FALSE = 0,TRUE =1};
13 enum bool slave_can_print = TRUE;
14 enum bool main_can_print = FALSE;
15 
16 pthread_cond_t cond_slave = PTHREAD_COND_INITIALIZER;
17 pthread_cond_t cond_main =  PTHREAD_COND_INITIALIZER;
18 
19 
20 pthread_mutex_t mutex_slave = PTHREAD_MUTEX_INITIALIZER;
21 pthread_mutex_t mutex_main = PTHREAD_MUTEX_INITIALIZER;
22 
23 void* thread_fun(void* arg);
24 void printf_msg(int type);
25 
26 int main(int argc, char* argv[])
27 {
28     pthread_t tid;
29     int ret;
30     ret = pthread_create(&tid,NULL,thread_fun,NULL);
31     if( ret != 0 )
32     {
33         strerror(ret);
34     }
35     while(loop_count_main > 0)
36     {
37         pthread_mutex_lock(&mutex_main);
38         if(main_can_print)
39         {
40             printf_msg(1);
41             loop_count_main -- ;
42             main_can_print = FALSE ;
43             pthread_mutex_lock(&mutex_slave);
44             slave_can_print = TRUE;
45             pthread_mutex_unlock(&mutex_slave);
46             pthread_cond_signal(&cond_slave);
47         }
48         else
49         {
50             pthread_cond_wait(&cond_main,&mutex_main);
51         }
52         pthread_mutex_unlock(&mutex_main);
53     }
54 
55 }
56 void* thread_fun(void* arg)
57 {
58     while(loop_count_slave > 0)
59     {
60         pthread_mutex_lock(&mutex_slave);
61         if(slave_can_print)
62         {
63             printf_msg(2);
64             loop_count_slave -- ;
65             slave_can_print = FALSE;
66             pthread_mutex_lock(&mutex_main);
67             main_can_print = TRUE;
68             pthread_mutex_unlock(&mutex_main);
69             pthread_cond_signal(&cond_main);
70         }
71         else
72         {
73             pthread_cond_wait(&cond_slave,&mutex_slave);
74         }
75         pthread_mutex_unlock(&mutex_slave);
76     }
77 
78     return NULL;
79 }
80 void printf_msg(int type)
81 {
82     if(type == 1)
83     {
84         int i = 0;
85         for(; i < LOOP_5; i++)
86         {
87             printf("from master \n");
88 
89         }
90     }
91     else if(type == 2)
92     {
93         int i = 0;
94         for(; i < LOOP_2; i++)
95         {
96             printf("from slave thread\n");
97         }
98     }
99 }

比較兩次執行，使用條件變量大概耗時只有0.002s，不使用條件變量大概0.2s，性能相差巨大。

原因在於不使用條件變量時，一直在忙循環，測試條件。

兩個線程交替打印信息