四十一、Linux 线程——线程同步之条件变量

41.1 概念

41.1.1 条件变量的介绍

• 互斥锁的缺点是它只有两种状态：锁定和非锁定
• 条件变量通过允许线程阻塞和等待另一个线程发送信号的方法弥补了互斥锁的不足
• 条件变量内部是一个等待队列，放置等待的线程，线程在条件变量上等待和通知，互斥锁用来保护等待队列（对等待队列上锁），条件变量通常和互斥锁一起使用
• 条件变量允许线程等待特定条件发生，当条件不满足时，线程通常先进入阻塞状态，等待条件发生变化。一旦其它的某个线程改变了条件，可唤醒一个或多个阻塞的线程
• 具体的判断条件还需用户给出
• 条件变量数据类型： pthread_cond_t

41.1.2 条件变量创建和销毁

 #include <pthread.h>
 int pthread_cond_init(pthread_cond_t *restrict cond, pthread_condattr_t *restrict attr);
 int pthread_cond_destroy(pthread_cond_t *cond);

• 函数参数：
  • cond：条件变量
  • attr：条件变量属性
• 返回值：
  • 成功，返回 0；出错，返回错误编号

41.1.3 条件变量等待操作

 #include <pthread.h>
 int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
 int pthread_cond_timewait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict timeout);

 struct timespec {
     time_t tv_sec;  /** seconds */
     ong tv_nsec;    /** nanoseconds */
 };

• 函数参数：
  • cond：条件变量
  • mutex：互斥锁
• 返回值：成功，返回 0，出错，返回错误编号
• 互斥锁 mutex 是对条件变量 cond 的保护
• 线程由于调用 wait 函数阻塞，否则释放互斥锁

41.1.4 条件变量通知操作

 #include <pthread.h>
 int pthread_cond_signal(pthread_cond_t *cond);
 int pthread_cond_broadcast(pthread_cond_t *cond);

• 函数参数：
  • cond：条件变量
• 返回值：成功，返回 0；失败，返回错误编号
• 当条件满足，线程需要通知等待的线程
• pthread_cond_signal 函数通知单个线程
• pthread_cond_broadcast 函数通知所有线程

41.1.5 pthread_cond_wait(cond, mutex) 函数内部流程

1. unlock(&mutex)：释放锁
2. lock(&mutex)
3. 将线程自己插入到条件变量的等待队列中
4. unlock(&mutex)；
5. 当前等待的线程阻塞 <<== 等待其他线程通知唤醒（signal 或 broadcast）
6. 在唤醒后，lock(&mutex)
7. 从等待队列中删除线程自己

41.2 例子

　　一个线程负责计算结果，一个线程负责获取结果

 #include <stdio.h>
 #include <stdlib.h>
 #include <pthread.h>
 #include <unistd.h>

 /** 两个线程定义的共享资源 */
 typedef struct {
     int res;
     int is_wait;    ///< 用户给出的用于判断的条件
     pthread_cond_t cond;    ///< 条件变量
     pthread_mutex_t mutex;  ///< 互斥锁
 }Result;

 /** 计算并将结果放置在 Result 中的线程运行函数 */
 void *set_fn(void *arg)
 {
     Result *r = (Result *)arg;
     int i = ;
     int sum = ;

     for(; i <= ; i++){
         sum += i;
     }

     /** 将结果放置到 Result 中 */
     r->res = sum;

     pthread_mutex_lock(&r->mutex);
     /** 判断获取结果的线程是否准备好 */
     while(!r->is_wait){
         pthread_mutex_unlock(&r->mutex);
         usleep();
         pthread_mutex_lock(&r->mutex);
     }
     pthread_mutex_unlock(&r->mutex);

     /** 通知唤醒等待的那个获取结果的线程 */
     pthread_cond_broadcast(&r->cond);

     return (void *);
 }

 /** 获得结果的线程运行函数 */
 void *get_fn(void *arg)
 {
     Result *r = (Result *)arg;

     /** 对两个线程共享的判断条件进行保护（加锁） */
     /** 两个线程对判断条件的操作是互斥的 */
     pthread_mutex_lock(&r->mutex);
     /** 当线程启动后，将此变量设置为1，代表此线程已经准备好了 */
     r->is_wait = ;

     /** 获取结果的线程等待 */
     pthread_cond_wait(&r->cond, &r->mutex);

     /** 被唤醒后 */
     pthread_mutex_unlock(&r->mutex);

     /** 去获取计算结果 */
     int res = r->res;
     printf("0x%lx get sum is %d\n", pthread_self(), res);

     return (void *);
 }

 int main(void)
 {
     int err;
     pthread_t cal, get;

     Result r;
     r.is_wait = ;
     pthread_cond_init(&r.cond, NULL);
     pthread_mutex_init(&r.mutex, NULL);

     /** 启动获取结果的线程 */
     if((err = pthread_create(&get, NULL, get_fn, (void *)&r)) != ){
         perror("pthread create error");
     }

     /** 启动计算结果的线程 */
     if((err = pthread_create(&cal, NULL, set_fn, (void *)&r)) != ){
         perror("pthread create error");
     }

     pthread_join(cal, NULL);
     pthread_join(get, NULL);

     pthread_cond_destroy(&r.cond);
     pthread_mutex_destroy(&r.mutex);

     pthread_cond_destroy(&r.cond);
     pthread_mutex_destroy(&r.mutex);
     return ;
 }

　　编译执行结果：