多线程--条件变量

这次学习和互斥锁一起应用的cond--条件变量

1.互斥锁的存在问题：

互斥锁一个明显的缺点是它只有两种状态：锁定和非锁定。设想一种简单情景：多个线程访问同一个共享资源时，并不知道何时应该使用共享资源，如果在临界区里加入判断语句，或者可以有效，但一来效率不高，二来复杂环境下就难以编写了，这是我们需要一个结构，能在条件成立时触发相应线程，进行变量修改和访问。

2.条件变量:

条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足，它常和互斥锁一起使用。使用时，条件变量被用来阻塞一个线程，当条件不满足时，线程往往解开相应的互斥锁并等待条件发生变化。一旦其它的某个线程改变了条件变量，它将通知相应的条件变量唤醒一个或多个正被此条件变量阻塞的线程。这些线程将重新锁定互斥锁并重新测试条件是否满足。

3.条件变量的相关函数

头文件：#include <pthread.h>
       pthread_cond_t cond = PTHREAD_COND_INITIALIZER; //条件变量结构
       int    pthread_cond_init(pthread_cond_t    *cond,    pthread_condattr_t
       *cond_attr);
       int pthread_cond_signal(pthread_cond_t *cond);
       int pthread_cond_broadcast(pthread_cond_t *cond);
       int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
       int   pthread_cond_timedwait(pthread_cond_t   *cond,    pthread_mutex_t
       *mutex, const struct timespec *abstime);
       int pthread_cond_destroy(pthread_cond_t *cond);

详细说明：

  （1）创建和注销

条件变量和互斥锁一样，都有静态动态两种创建方式

 a.静态方式

静态方式使用PTHREAD_COND_INITIALIZER常量，如下：
pthread_cond_t cond=PTHREAD_COND_INITIALIZER

 b.动态方式

动态方式调用pthread_cond_init()函数，API定义如下：
int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr)

尽管POSIX标准中为条件变量定义了属性，但在LinuxThreads中没有实现，因此cond_attr值通常为NULL，且被忽略。

注销一个条件变量需要调用pthread_cond_destroy()，只有在没有线程在该条件变量上等待的时候才能注销这个条件变量，否则返回EBUSY。因为Linux实现的条件变量没有分配什么资源，所以注销动作只包括检查是否有等待线程。API定义如下：
int pthread_cond_destroy(pthread_cond_t *cond)

（2）等待和激发

a.等待

int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)//等待
int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, const struct timespec *abstime)//有时等待

 

wait的执行：调用wait这个线程把锁住的互斥量传给该wait，函数把调用者线程放到等待条件的线程列表上，然后对互斥量解锁，这两个操作时原子操作。

pthread_cond_wait会先解除之前的pthread_mutex_lock锁定的mtx，然后阻塞在等待对列里休眠，直到再次被唤醒（大多数情况下是等待的条件成立而被唤醒，唤醒后，该进程会先锁定先pthread_mutex_lock(&mtx);，再读取资源 。            //用这个流程是比较清楚的/*block-->unlock-->wait() return-->lock*/   

 

等待条件有两种方式：无条件等待pthread_cond_wait()和计时等待pthread_cond_timedwait()，其中计时等待方式如果在给定时刻前条件没有满足，则返回ETIMEOUT，结束等待，其中abstime以与time()系统调用相同意义的绝对时间形式出现，0表示格林尼治时间1970年1月1日0时0分0秒。

无论哪种等待方式，都必须和一个互斥锁配合，以防止多个线程同时请求pthread_cond_wait()（或 pthread_cond_timedwait()，下同）的竞争条件（Race Condition）。mutex互斥锁必须是普通锁（PTHREAD_MUTEX_TIMED_NP）或者适应锁（PTHREAD_MUTEX_ADAPTIVE_NP），且在调用pthread_cond_wait()前必须由本线程加锁（pthread_mutex_lock()），而在更新条件等待队列以前，mutex保持锁定状态，并在线程挂起进入等待前解锁。在条件满足从而离开 pthread_cond_wait()之前，mutex将被重新加锁，以与进入pthread_cond_wait()前的加锁动作对应。

b.激发

激发条件有两种形式，pthread_cond_signal()激活一个等待该条件的线程，存在多个等待线程时按入队顺序激活其中一个；而pthread_cond_broadcast()则激活所有等待线程。

（3）． 其他操作

pthread_cond_wait ()和pthread_cond_timedwait()都被实现为取消点，因此，在该处等待的线程将立即重新运行，在重新锁定mutex后离开 pthread_cond_wait()，然后执行取消动作。也就是说如果pthread_cond_wait()被取消，mutex是保持锁定状态的，因而需要定义退出回调函数来为其解锁。

4. 异步信号安全(Async-signal Safety)                                                                                         
    条件变量函数不是异步信号安全的，不应当在信号处理程序中进行调用。特别要注意，如果在信号处理程序中调用 pthread_cond_signal 或 pthread_cond_boardcast 函数，可能导致调用线程死锁。
                                                                                         
5. 返回值
    在执行成功时，所有条件变量函数都返回 0，错误时返回非零的错误代码。
6. 错误代码
    pthread_cond_init,   pthread_cond_signal,  pthread_cond_broadcast, 和 pthread_cond_wait 从不返回错误代码。
    pthread_cond_timedwait 函数出错时返回下列错误代码：
        ETIMEDOUT   abstime 指定的时间超时时，条件变量未触发
        EINTR       pthread_cond_timedwait 被触发中断
    pthread_cond_destroy 函数出错时返回下列错误代码：
        EBUSY       某些线程正在等待该条件变量

7. 举例                                                                                    
    设有两个共享的变量 x 和 y，通过互斥量 mut 保护，当 x > y 时，条件变量 cond 被触发。
             int x,y;
             int x,y;
             pthread_mutex_t mut = PTHREAD_MUTEX_INITIALIZER;
             pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
                                                                                         
    等待直到 x > y 的执行流程：
              pthread_mutex_lock(&mut);
              while (x <= y) {
                      pthread_cond_wait(&cond, &mut);
              }
             
              pthread_mutex_unlock(&mut);
                                                                                         
     对 x 和 y 的修改可能导致 x > y，应当触发条件变量：                                                                                         
              pthread_mutex_lock(&mut);
             
              if (x > y) pthread_cond_broadcast(&cond);
              pthread_mutex_unlock(&mut);
                                                                                         
    如果能够确定最多只有一个等待线程需要被唤醒(例如，如果只有两个线程通过 x、y 通信)，则使用 pthread_cond_signal 比 pthread_cond_broadcast 效率稍高一些。如果不能确定，应当用 pthread_cond_broadcast。
    要等待在 5 秒内 x > y，这样处理：
                                                                                         
              struct timeval now;
              struct timespec timeout;
              int retcode;
                                                                                         
              pthread_mutex_lock(&mut);
              gettimeofday(&now);
              timeout.tv_sec = now.tv_sec + 5;
              timeout.tv_nsec = now.tv_usec * 1000;
              retcode = 0;
              while (x <= y && retcode != ETIMEDOUT) {
                      retcode = pthread_cond_timedwait(&cond, &mut, &timeout);
              }
              if (retcode == ETIMEDOUT) {
                     
              } else {
                     
              }
              pthread_mutex_unlock(&mut);

8、看完基本操作后做一个小练习：

建立两个线程1、2，两个线程分别访问共享资源，并进行加 1操作，当共享资源<=3时，线程1挂起不操作，这时线程2工作，共享资源>3后，两者都工作

1.   
2. #include <stdlib.h>    
3. #include <stdio.h>    
4. #include <pthread.h>    
5. #include <errno.h>    
   
6.   
7.   
8. int gnum = 0;  
9.   
10. pthread_mutex_t mutex;  
11.   
12. pthread_cond_t  cond;  
13.   
14.   
15. static void pthread_func_1 (void);     
16. static void pthread_func_2 (void);     
17.   
18. int main (void)     
19. {     
20.       
21.     pthread_t pt_1 = 0;     
22.     pthread_t pt_2 = 0;     
23.     int ret = 0;     
24.       
25.       
26.     pthread_mutex_init (&mutex, NULL);   
27.       
28.     pthread_cond_init(&cond,NULL);  
29.       
30.     ret = pthread_create (&pt_1,            //线程标识符指针  
31.         NULL,           //默认属性  
32.         (void *)pthread_func_1,//运行函数  
33.         NULL);          //无参数  
34.     if (ret != 0)     
35.     {     
36.         perror ("pthread_1_create");     
37.     }     
38.       
39.     ret = pthread_create (&pt_2,            //线程标识符指针  
40.         NULL,           //默认属性    
41.         (void *)pthread_func_2, //运行函数  
42.         NULL);          //无参数  
43.     if (ret != 0)     
44.     {     
45.         perror ("pthread_2_create");     
46.     }     
47.       
48.     pthread_join (pt_1, NULL);     
49.     pthread_join (pt_2, NULL);     
50.       
51.     printf ("main programme exit!\n");    
52.     return 0;     
53. }     
54.   
55.   
56. static void pthread_func_1 (void)     
57. {     
58.     int i = 0;     
59.       
60.     for (;;)     
61.     {     
62.         printf ("This is pthread1!\n");      
63.         pthread_mutex_lock(&mutex);   
64.           
65.         sleep (1);  
66.           
67.         while (gnum <= 3) {  
68.             pthread_cond_wait(&cond, &mutex);  
69.         }  
70.           
71.           
72.         gnum++;  
73.         printf ("Thread1 add one to num:%d\n",gnum);  
74.         pthread_mutex_unlock(&mutex);   
75.           
76.           
77.           
78.     }     
79. }     
80.    
81. static void pthread_func_2 (void)     
82. {     
83.     int i = 0;     
84.       
85.     for (;;)     
86.     {     
87.         printf ("This is pthread2!\n");   
88.         pthread_mutex_lock(&mutex);   
89.           
90.         sleep (1);  
91.           
92.         gnum++;  
93.         printf ("Thread2 add one to num:%d\n",gnum);  
94.           
95.         if (gnum == 4)   
96.             pthread_cond_signal(&cond);  
97.           
98.         pthread_mutex_unlock(&mutex);   
99.           
100.     }     
101.       
102.     pthread_exit (0);     
103. }   
     

编译，运行，可以看到预期结果，这里只是一个简单练习，以后再深入研究条件变量，用条件变量解决生产者--消费者问题