• Linux系统编程系列之条件变量

     Linux系统编程系列（16篇管饱，吃货都投降了！）

            1、Linux系统编程系列之进程基础

            2、Linux系统编程系列之进程间通信(IPC)-信号

            3、Linux系统编程系列之进程间通信(IPC)-管道

            4、Linux系统编程系列之进程间通信-IPC对象

            5、Linux系统编程系列之进程间通信-消息队列

            6、Linux系统编程系列之进程间通信-共享内存

            7、Linux系统编程系列之进程间通信-信号量组

            8、Linux系统编程系列之守护进程

            9、Linux系统编程系列之线程

            10、Linux系统编程系列之线程属性 

            11、Linux系统编程系列之互斥锁和读写锁

            12、Linux系统编程系列之线程的信号处理

            13、Linux系统编程系列之POSIX信号量

            14、Linux系统编程系列之条件变量

            15、Linux系统编程系列之死锁

            16、 Linux系统编程系列之线程池

    一、什么是条件变量

            条件变量是一种同步互斥机制，通常与互斥锁一起使用以实现线程之间的通信和同步。

    二、问题的引入

            先来看一个例子:小楠是一名在校学生，每个月都会从父母那里得到一笔生活费。现在她的钱花光了，想要去取钱。但是很显然取钱这样的事情不是想干就能干的，前提是卡里必须得有钱才行！于是小楠拿起手机一查发现:余额为￥0。现在她除了干瞪眼，唯一能干的事情也许只有一件:等。等到她爸妈汇了钱打电话通知她为止。

            但更进一步，即便是她爸妈汇了钱也打了电话通知了她，此刻她也不能一定保证能取到钱，因为与此同时她的众多兄弟姐妹（统统共用一个银行账号）很可能已经抢先一步将钱悉数取光了!因此当小楠收到爸妈的电话之后，需要再次确认是否有钱，才能取钱。

    三、使用场景

            （1）、 生产者-消费者模式：多个线程生产数据，多个线程消费数据。消费者等待条件变量，当生产者生产数据时唤醒消费者。

            （2）、 服务器程序：服务器可以使用条件变量来实现多个客户端之间的同步操作。当客户端请求数据时，服务器可能需要等待某些资源准备好后才能响应，此时可以使用条件变量来等待资源就绪。

            （3）、 任务管理：当有多个线程需要执行任务时，可以使用条件变量来通知空闲的线程执行任务。

            （4）、 等待输入：当需要等待用户输入时，可以使用条件变量等待用户输入。

            总之，当需要等待某些条件满足时，使用条件变量是很常见的一种方式。条件变量提供了一个有效的机制来等待和通知多个线程，以实现共享资源间的同步和互斥。

    四、相关的函数API接口

            1、初始化条件变量

    1. // 初始化条件变量
    2. int pthread_cond_init(pthread_cond_t *cond, pthread_condattr_t *cond_attr);
    3.  
    4. // 接口说明
    5.         返回值：成功返回0，失败返回-1
    6.         参数cond：待初始化的条件变量
    7.         参数cond_attr：待初始化的条件变量的属性，一般始终为0

             2、销毁条件变量

    1. // 销毁条件变量
    2. int pthread_cond_destroy(pthread_cond_t *cond);
    3.  
    4. // 接口说明
    5.         返回值：成功返回0，失败返回错误码
    6.         参数cond：待销毁的条件变量

            3、 进入等待队列

    1. // 阻塞等待
    2. int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex);
    3.  
    4. // 接口说明
    5.         返回值；成功返回0，失败返回-1
    6.         参数cond：条件变量
    7.         参数mutex：需要获取的互斥锁
    8.  
    9. // 有限定时间的等待
    10. int pthread_cond_timedwait(pthread_cond_t *cond, 
    11.                            pthread_mutex_t *mutex, 
    12.                            const struct timespec *abstime);
    13.  
    14. // 接口说明
    15.         返回值；成功返回0，失败返回-1
    16.         参数cond：条件变量
    17.         参数mutex：需要获取的互斥锁
    18.         参数abstime：限定的时间

            4、唤醒等待队列 

    1. // 唤醒全部在条件变量等待队列的线程
    2. int pthread_cond_broadcast(pthread_cond_t *cond);
    3.  
    4. // 唤醒一个在条件变量等待队列的线程
    5. int pthread_cond_signal(pthread_cond_t *cond);
    6.  
    7. // 接口说明
    8.         返回值：成功返回0，失败返回-1
    9.         参数cond：条件变量

    五、案例

            使用条件变量结合互斥锁完成存钱和取钱的演示

    1. // 条件变量的案例
    2.  
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8.  
    9. int money = 0;
    10.  
    11. pthread_mutex_t data_mutex; // 定义互斥锁变量
    12. pthread_once_t data_mutex_once_init;    // 函数单例初始化变量
    13. pthread_once_t data_mutex_once_destroy;    // 函数单例销毁变量
    14.  
    15. pthread_cond_t data_cond; // 定义条件变量
    16. pthread_once_t data_cond_once_init;    // 函数单例初始化变量
    17. pthread_once_t data_cond_once_destroy;    // 函数单例销毁变量
    18.  
    19. // 初始化互斥锁data_mutex
    20. void data_mutex_init(void)
    21. {
    22.     pthread_mutex_init(&data_mutex, NULL);
    23. }
    24.  
    25. // 销毁互斥锁data_mutex
    26. void data_mutex_destroy(void)
    27. {
    28.     pthread_mutex_destroy(&data_mutex);
    29. }
    30.  
    31. // 初始化条件变量data_cond
    32. void data_cond_init(void)
    33. {
    34.     pthread_cond_init(&data_cond, NULL);
    35. }
    36.  
    37. // 销毁条件变量data_cond
    38. void data_cond_destroy(void)
    39. {
    40.     pthread_cond_destroy(&data_cond);
    41. }
    42.  
    43. // 线程1的例程函数，用来取钱
    44. void *get_routine(void *arg)
    45. {
    46.     printf("I am recv_routine, my tid = %ld\n", pthread_self());
    47.  
    48.     // 设置线程分离 
    49.     pthread_detach(pthread_self()); 
    50.  
    51.     // 函数单例，本程序只会执行data_mutex_init()一次
    52.     pthread_once(&data_mutex_once_init, data_mutex_init);
    53.  
    54.     // 函数单例，本程序只会执行data_cond_init()一次
    55.     pthread_once(&data_cond_once_init, data_cond_init);
    56.  
    57.     while(1)
    58.     {
    59.         printf("wait mutex to get money...\n");
    60.         pthread_mutex_lock(&data_mutex);    // 阻塞等待有数据才可以申请成功，用来同步
    61.         printf("get mutex to get money\n");
    62.  
    63.         // 判断余额是否大于100
    64.         while(money < 100)
    65.         {
    66.             printf("get money fail, enter cond queue\n");
    67.  
    68.             // 这里先自动解锁data_mutex，等待被唤醒后，会自动上锁data_mutex
    69.             pthread_cond_wait(&data_cond, &data_mutex);
    70.  
    71.             printf("wake up from cond queue\n");
    72.         }
    73.  
    74.         money -= 100;
    75.         printf("get money success\n");
    76.         pthread_mutex_unlock(&data_mutex); // 解锁
    77.      
    78.         sleep(1); // 每隔1秒取100元
    79.     }   
    80.  
    81.     // 函数单例，本程序只会执行data_mutex_destroy()一次
    82.     pthread_once(&data_mutex_once_destroy, data_mutex_destroy);
    83.  
    84.     // 函数单例，本程序只会执行data_cond_destroy()一次
    85.     pthread_once(&data_cond_once_destroy, data_cond_destroy);
    86. }
    87.  
    88. // 线程2的例程函数，用来存钱
    89. void *give_routine(void *arg)
    90. {
    91.     printf("I am send_routine, my tid = %ld\n", pthread_self());
    92.  
    93.     // 函数单例，本程序只会执行data_mutex_init()一次
    94.     pthread_once(&data_mutex_once_init, data_mutex_init);
    95.  
    96.     // 函数单例，本程序只会执行data_cond_init()一次
    97.     pthread_once(&data_cond_once_init, data_cond_init);
    98.  
    99.  
    100.     while(1)
    101.     {
    102.         pthread_mutex_lock(&data_mutex);
    103.         money += 200;
    104.  
    105.         // printf()应该放到临界区外面，但是为了演示效果所以放在这里
    106.         printf("current money is %d\n", money); 
    107.  
    108.         pthread_mutex_unlock(&data_mutex);  // 解锁，相当于给线程1发送信号
    109.  
    110.         pthread_cond_broadcast(&data_cond); // 唤醒条件等待队列中等待的线程
    111.  
    112.         sleep(3); // 每隔3秒存200元
    113.     }
    114.  
    115.    // 函数单例，本程序只会执行data_mutex_destroy()一次
    116.     pthread_once(&data_mutex_once_destroy, data_mutex_destroy);
    117.  
    118.     // 函数单例，本程序只会执行data_cond_destroy()一次
    119.     pthread_once(&data_cond_once_destroy, data_cond_destroy);
    120. }
    121.  
    122. int main(int argc, char *argv[])
    123. {
    124.     pthread_t tid1, tid2;
    125.  
    126.     // 创建线程1，用来取钱
    127.     errno = pthread_create(&tid1, NULL, get_routine, NULL);
    128.     if(errno == 0)
    129.     {
    130.         printf("pthread create get_routine success, tid = %ld\n", tid1);
    131.     }
    132.     else
    133.     {
    134.         perror("pthread create get_routine fail\n");
    135.     }
    136.  
    137.     
    138.     // 创建线程2，用来存钱，线程拥有分离属性
    139.     errno = pthread_create(&tid2, NULL, give_routine, NULL);
    140.     if(errno == 0)
    141.     {
    142.         printf("pthread create give_routine success, tid = %ld\n", tid2);
    143.     }
    144.     else
    145.     {
    146.         perror("pthread create give_routine fail\n");
    147.     }
    148.  
    149.     // 一定要加这个，否则主函数直接退出，相当于进程退出，所有线程也退出
    150.     // 或者加上while(1)等让主函数不退出
    151.     pthread_exit(0);
    152.     
    153.     return 0;
    154. }

    六、总结

            条件变量通常用于多线程间共享资源的同步访问，一般要配合互斥锁来使用，可以结合案例来加深对条件变量的理解。

  • 相关阅读:
    2023最新SSM计算机毕业设计选题大全（附源码+LW）之java拼车平台0k47u
    C++的类和对象（六）：友元、内部类
    阿里 P9 用 500 多页手册完成双十一高并发秒杀系统，绝了
    java计算机毕业设计西安市城市绿地管理系统源码+数据库+系统+lw文档+mybatis+运行部署
    DBeaver使用
    【python桌面应用设计】tkinter库 02. 常用控件和属性
    git学习(一)
    Linux sed工具的使用
    coco数据集json文件转换成YOLO版的txt文件代码
    闪光激光雷达实现无人驾驶导航
  • 原文地址：https://blog.csdn.net/AABond/article/details/133418980