AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

二、(LINUX 线程同步) 互斥量、条件变量以及生产者消费者问题

2017-05-20 869
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 原创转载请注明出处： 接上一篇：一、(LINUX 线程同步) 引入  http://blog.itpub.net/7728585/viewspace-2137980/ 在线程同步中我们经常会使用到mutex互斥量，其作用用于保护一块临界区，避免多线程并发操作对这片临界区带来的数据混乱， POSIX的互斥量是一种建议锁，因为如果不使用互斥量也可以访问共享数据，但是可能是不安全的。
原创转载请注明出处：

接上一篇：

一、(LINUX 线程同步) 引入  http://blog.itpub.net/7728585/viewspace-2137980/

在线程同步中我们经常会使用到mutex互斥量，其作用用于保护一块临界区，避免多线程并发操作对这片临界区带来的数据混乱，
POSIX的互斥量是一种建议锁，因为如果不使用互斥量也可以访问共享数据，但是可能是不安全的。
其原语包含：
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER; 
静态初始一个互斥量
int pthread_mutex_destroy(pthread_mutex_t *mutex);
销毁一个互斥量
int pthread_mutex_init(pthread_mutex_t *restrict mutex, const pthread_mutexattr_t *restrict attr);
初始化一个互斥量
int pthread_mutex_lock(pthread_mutex_t *mutex);
互斥量加锁操作，在这个函数调用下的临界区只允许一个线程进行访问，如果不能获得锁则堵塞等待
int pthread_mutex_trylock(pthread_mutex_t *mutex);
互斥量加锁操作，在这个函数调用下的临界区只允许一个线程进行访问，如果获得不了锁则放弃
int pthread_mutex_unlock(pthread_mutex_t *mutex);
互斥量解锁操作，一般用于在临界区数据操作完成后解锁


而条件变量cond则代表当某个条件不满足的情况下，本线程应该放弃锁，并且将本线程堵塞。典型的
生产者消费者问题，如果生产者还没来得及生产东西，消费者则不应该进行消费操作，应该放弃锁，将
自己堵塞，直到条件满足被生产者唤醒。原语包含：
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
静态初始一个条件变量
int pthread_cond_init(pthread_cond_t *cond,const pthread_condattr_t *cattr);
初始化一个条件变量
int pthread_cond_destroy(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_signal(pthread_cond_t *cond)
条件满足唤醒由于wait在这个条件变量上某个线程，一般用于生产者唤醒消费者
int pthread_cond_broadcast(pthread_cond_t *cond)
条件满足唤醒由于wait在这个条件变量上全部线程，一般用于生产者唤醒消费者

下面一张自己画的图希望对大家有所帮助。


最后是我写的一个，用一个链表栈结构，来模拟一个生产者生产数据，N个消费者并发进行消费的
一个生产者消费者程序。生产者一次生产一批数据，消费者一次只消费一个数据。
当生产者一次生产10个数据的时候，输出是这样的。
p:thread:140034536785664 prod 1 data is:data A:0 data B:0
p:thread:140034536785664 prod 2 data is:data A:1 data B:1
p:thread:140034536785664 prod 3 data is:data A:2 data B:2
p:thread:140034536785664 prod 4 data is:data A:3 data B:3
p:thread:140034536785664 prod 5 data is:data A:4 data B:4
p:thread:140034536785664 prod 6 data is:data A:5 data B:5
p:thread:140034536785664 prod 7 data is:data A:6 data B:6
p:thread:140034536785664 prod 8 data is:data A:7 data B:7
p:thread:140034536785664 prod 9 data is:data A:8 data B:8
p:thread:140034536785664 prod 10 data is:data A:9 data B:9
c:thread:140034520000256 cost 10 data is:data A:9 data B:9
c:thread:140034520000256 cost 9 data is:data A:8 data B:8
c:thread:140034520000256 cost 8 data is:data A:7 data B:7
c:thread:140034520000256 cost 7 data is:data A:6 data B:6
c:thread:140034520000256 cost 6 data is:data A:5 data B:5
c:thread:140034520000256 cost 5 data is:data A:4 data B:4
c:thread:140034520000256 cost 4 data is:data A:3 data B:3
c:thread:140034520000256 cost 3 data is:data A:2 data B:2
c:thread:140034520000256 cost 2 data is:data A:1 data B:1
c:thread:140034520000256 cost 1 data is:data A:0 data B:0
也可以看到他确实是一个后进先出的栈模型
这个时候并没有观察到多个线程竞争的问题，如果我将生产者定义为一次生产10000个数据，就可以
看到多个线程交替使用生产者数据的情况。
c:thread:140270541522688 cost 9959 data is:data A:9958 data B:9958 c:thread:140270667347712 cost 9952 data is:data A:9951 data B:9951
我们可以看到不同的线程ID的线程在竞争这把锁
下面是代码，临界区应该尽量选择小，我这里临界区选择较大，比如链表的创建
c:thread:140270692525824 cost 9962 data is:data A:9961 data B:9961
c:thread:140270692525824 cost 9961 data is:data A:9960 data B:9960
c:thread:140270692525824 cost 9960 data is:data A:9959 data B:9959
c:thread:140270541522688 cost 9959 data is:data A:9958 data B:9958
c:thread:140270541522688 cost 9958 data is:data A:9957 data B:9957
c:thread:140270541522688 cost 9957 data is:data A:9956 data B:9956
c:thread:140270541522688 cost 9956 data is:data A:9955 data B:9955
c:thread:140270541522688 cost 9955 data is:data A:9954 data B:9954
c:thread:140270541522688 cost 9954 data is:data A:9953 data B:9953
c:thread:140270541522688 cost 9953 data is:data A:9952 data B:9952
c:thread:140270667347712 cost 9952 data is:data A:9951 data B:9951
其实不需要放到临界区中，还比如内存的delete也不需要放到临界区，处于测试
目的已经达到，就不在纠结这个问题了：

点击(此处)折叠或打开

  1. 头文件：
  2. /*************************************************************************
  3.   > File Name: chain.h
  4.   > Author: gaopeng QQ:22389860 all right reserved
  5.   > Mail: gaopp_200217@163.com
  6.   > Created Time: Sun 04 Jun 2017 06:27:38 AM CST
  7.  ************************************************************************/

  9. #include<iostream>
  10. #include<stdio.h>
  11. #include <stdlib.h>
  12. #include <unistd.h>

  14. #define MAX_TID 10
  15. using namespace std;


  18. class t1data
  19. {
  20.         private:
  21.                 int a;
  22.                 int b;
  23.         public:
  24.                 t1data(){}
  25.                 t1data(int i)
  26.                 {
  27.                         this->a = i;
  28.                         this->b = i;
  29.                 }
  30.                 virtual void prin(void)
  31.                 {
  32.                         cout<<"data A:"<<a<<" data B:"<<b;
  33.                 }

  35. };


  38. typedef struct queue_s 
  39. {
  40.         t1data data;
  41.         queue_s *next,*priv;
  42.         queue_s(int i)
  43.         {
  44.                 data = t1data(i);
  45.                 next = NULL;
  46.                 priv = NULL;
  47.         }
  48. } QUE_S,*QUE_S_P ;

  50. typedef struct queue_h
  51. {
  52.         QUE_S_P head_p;
  53.         QUE_S_P last_p;
  54.         unsigned int len;
  55.         pthread_mutex_t pmut;
  56.         pthread_cond_t pcon;
  57.         queue_h()
  58.         {
  59.                 head_p=NULL;
  60.                 last_p=NULL;
  61.                 len = 0;
  62.         }
  63. } QUE_H;

  65. int debug_return(const int ret)
  66. {
  67.         if(ret != 0)
  68.         {
  69.                 strerror(ret);
  70.                 exit(-1);
  71.         }
  72.         return 0;
  73. }
主文件：

点击(此处)折叠或打开

  1. /*************************************************************************
  2.   > File Name: main.cpp
  3.   > Author: gaopeng QQ:22389860 all right reserved
  4.   > Mail: gaopp_200217@163.com
  5.   > Created Time: Sun 04 Jun 2017 07:18:28 AM CST
  6.  ************************************************************************/

  8. #include<iostream>
  9. #include<stdio.h>
  10. #include <pthread.h>
  11. #include<string.h>
  12. #include"chain.h"

  14. #define MAXDATA 10000
  15. //双向链表栈结构模型

  17. using namespace std;

  19. static int COUNT = 0;


  22. void* pro(void* arg)
  23. {

  25.         QUE_H* my_head;
  26.         my_head = (QUE_H*)arg;
  27.         QUE_S_P sp =NULL;
  28.         int ret = 0;

  30.         while(1)
  31.         {
  32.                 ret = pthread_mutex_lock(&my_head->pmut);
  33.                 debug_return(ret);

  35.                 if(my_head->head_p != NULL)//如果元素没有消费完放弃MUTEX,进入下次循环
  36.                 {
  37.                         //cout<<"pro head != NULL unlock\n";
  38.                         ret = pthread_mutex_unlock(&my_head->pmut);
  39.                         debug_return(ret);
  40.                         continue;
  41.                 }
  42.                 //如果消费完进行生产10000个元素
  43.                 for(;COUNT<MAXDATA;COUNT++)//生产10000个元素
  44.                 {
  45.                         if(my_head->head_p == NULL)
  46.                         {
  47.                                 int tm = 0;
  48.                                 QUE_S_P sp = new QUE_S(COUNT);
  49.                                 my_head->head_p = sp;
  50.                                 my_head->last_p = sp;
  51.                                 cout<<"p:thread:"<<pthread_self()<<" prod "<<++my_head->len<<" data is:";
  52.                                 (my_head->last_p->data).prin();
  53.                                 cout<<"\n";
  54.                                 sp = NULL;
  55.                         }
  56.                         else
  57.                         {
  58.                                 QUE_S_P sp = new QUE_S(COUNT);
  59.                                 my_head->last_p->next = sp;
  60.                                 sp->priv = my_head->last_p;
  61.                                 my_head->last_p = sp;
  62.                                 cout<<"p:thread:"<<pthread_self()<<" prod "<<++my_head->len<<" data is:";
  63.                                 my_head->last_p->data.prin();
  64.                                 cout<<"\n";
  65.                                 sp = NULL;
  66.                         }
  67.                 }
  68.                 //cout<<"pro unlock:\n";
  69.                 ret = pthread_mutex_unlock(&my_head->pmut);
  70.                 debug_return(ret);
  71.                 //cout<<"pro signal:\n";
  72.                 ret = pthread_cond_signal(&my_head->pcon);
  73.                 debug_return(ret);

  75.         }

  77. }

  79. void* cus(void* arg)
  80. {
  81.         int ret = 0;
  82.         QUE_H* my_head;
  83.         my_head = (QUE_H*)arg;
  84.         QUE_S_P tmp=NULL;

  86.         while(1)//消费方式为一个消费线程只消费一个元素，来模拟多消费线程竞争
  87.         {
  88.                 ret = pthread_mutex_lock(&my_head->pmut);
  89.                 debug_return(ret);
  90.                 while(my_head->head_p == NULL) //如果已经消费完放弃锁，等到条件及有元素供消费
  91.                 {
  92.                         //cout<<"cus cond wait\n";
  93.                         ret = pthread_cond_wait(&my_head->pcon,&my_head->pmut);
  94.                         debug_return(ret);
  95.                 }

  97.                 if(my_head->len == 1)//消费如果只剩下一个元素处理
  98.                 {
  99.                         cout<<"c:thread:"<<pthread_self()<<" cost "<<my_head->len--<<" data is:";
  100.                         my_head->last_p->data.prin();
  101.                         delete my_head->last_p;
  102.                         my_head->head_p = NULL;
  103.                         my_head->last_p = NULL;
  104.                         COUNT--;
  105.                 }
  106.                 else//否则处理如下
  107.                 {
  108.                         cout<<"c:thread:"<<pthread_self()<<" cost "<<my_head->len--<<" data is:";
  109.                         my_head->last_p->data.prin();
  110.                         cout<<"\n";
  111.                         tmp = my_head->last_p->priv;
  112.                         delete my_head->last_p;
  113.                         my_head->last_p= tmp;
  114.                         tmp=NULL;
  115.                         COUNT--;
  116.                 }

  118.                 ret = pthread_mutex_unlock(&my_head->pmut);
  119.                 debug_return(ret);
  120.         }

  122. }


  125. int main(void)
  126. {
  127.         QUE_H my_head;
  128.         int ret = 0;
  129.         pthread_t tid[MAX_TID];
  130.         int tid_num = 0;
  131.         int i = 0;

  133.         ret = pthread_mutex_init(&my_head.pmut,NULL);
  134.         debug_return(ret);
  135.         ret = pthread_cond_init(&my_head.pcon,NULL);
  136.         debug_return(ret);
  137.         //一个生产者
  138.         ret = pthread_create(tid+tid_num,NULL,pro,(void*)&my_head);
  139.         debug_return(ret);
  140.         tid_num++;
  141.         //n个消费者
  142.         ret = pthread_create(tid+tid_num,NULL,cus,(void*)&my_head);
  143.         debug_return(ret);
  144.         tid_num++;
  145.         ret = pthread_create(tid+tid_num,NULL,cus,(void*)&my_head);
  146.         debug_return(ret);
  147.         tid_num++;
  148.         ret = pthread_create(tid+tid_num,NULL,cus,(void*)&my_head);
  149.         debug_return(ret);
  150.         tid_num++;
  151.         ret = pthread_create(tid+tid_num,NULL,cus,(void*)&my_head);
  152.         debug_return(ret);
  153.         tid_num++;
  154.         ret = pthread_create(tid+tid_num,NULL,cus,(void*)&my_head);
  155.         debug_return(ret);

  157.     //堵塞回收
  158.         for(i = 0;i<=tid_num;i++)
  159.         {
  160.                 ret = pthread_join( *(tid+i) , NULL );
  161.                 debug_return(ret);
  162.         }

  164.         ret=pthread_mutex_destroy(&my_head.pmut);
  165.         debug_return(ret);
  166.         ret=pthread_cond_destroy(&my_head.pcon);
  167.         debug_return(ret);

  169. }

作者微信：

               

文章标签：
Linux
关键词：
线程生产者
线程消费者
Linux线程
Linux线程变量
线程变量
重庆八怪
目录
相关文章
石小浪♪
|
2月前
|
资源调度 Linux 调度
Linux C/C++之线程基础
这篇文章详细介绍了Linux下C/C++线程的基本概念、创建和管理线程的方法，以及线程同步的各种机制，并通过实例代码展示了线程同步技术的应用。
石小浪♪
33 0
Linux C/C++之线程基础
游客zi3qmblbcdexu
|
2月前
|
安全 Linux
Linux线程（十一）线程互斥锁-条件变量详解
Linux线程（十一）线程互斥锁-条件变量详解
游客zi3qmblbcdexu
114 0
小狮子安度因1
|
4月前
|
存储 设计模式 NoSQL
Linux线程详解
Linux线程详解
小狮子安度因1
40 1
游客mldfis24krfue
|
4月前
|
负载均衡 Linux 调度
在Linux中，进程和线程有何作用?
在Linux中，进程和线程有何作用?
游客mldfis24krfue
57 0
石小浪♪
|
2月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念，包括进程和线程的定义、并发的实现方式，以及如何在C++中创建和管理线程，包括使用`std::thread`库、线程的join和detach方法，并通过示例代码展示了如何创建和使用多线程。
石小浪♪
55 1
C++ 多线程之初识多线程
龙大吉
|
2月前
|
Java 开发者
在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱，帮助你更好地理解和选择适合项目需求的线程创建方式。
龙大吉
26 3
东方睿赢
|
2月前
|
Java 开发者
在Java多线程编程中，选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中，选择合适的线程创建方法至关重要。本文通过案例分析，探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景，帮助开发者做出明智的选择。
东方睿赢
22 2
东方睿赢
|
2月前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析：线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景，帮助读者更好地理解和掌握多线程编程技术，为复杂任务的高效处理奠定基础。
东方睿赢
35 2
龙大吉
|
2月前
|
Java 开发者
Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点，重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
龙大吉
41 1
众所周知
|
2月前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法，探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法，探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法，并分享了最佳实践，帮助开发者避免常见陷阱，提高多线程程序的稳定性和效率。
众所周知
47 1

热门文章

最新文章

  • 1
    常用LINUX软件，下载后解压出来ISO文件，直接挂载到LINUX使用即可
  • 2
    如何在Linux下使用TCP封装器来加强网络服务安全
  • 3
    【Linux网络服务】Centos7搭建nfs文件共享服务器
  • 4
    Linux内核管理--进程（一）
  • 5
    Linux 清空登录信息
  • 6
    linux查看文件
  • 7
    Windows Linux 删除N天之前文件脚本
  • 8
    linux--nfs 网络文件共享
  • 9
    AIX下配置NFS共享给LINUX
  • 10
    Linux教程【一】
  • 1
    探索Python中的并发编程：协程与多线程的比较
    88
  • 2
    多线程在编程中的重要性有什么？并以LabVIEW为例进行说明
    59
  • 3
    Java一分钟之线程池：ExecutorService与Future
    149
  • 4
    深入理解Java并发编程：线程安全与性能优化
    49
  • 5
    linux线程与进程的区别及线程的优势
    71
  • 6
    Java一分钟：线程协作：wait(), notify(), notifyAll()
    68
  • 7
    Java一分钟：线程同步：synchronized关键字
    204
  • 8
    Java一分钟：多线程编程初步：Thread类与Runnable接口
    103
  • 9
    多线程业务异步处理
    78
  • 10
    深入理解Java并发编程：线程安全与性能优化
    42

    • 相关课程

    更多
  • Linux高级网络应用 - 网络管理与配置实战
  • Linux用户和组管理
  • Linux基本命令
  • Linux企业运维实战 - 入门及常用命令
  • Linux Shell 编程入门与实战
  • Linux网络进阶 - TCP/IP协议及OSI七层模型

    • 相关电子书

    更多
  • Alibaba Cloud Linux 3 发布
  • ECS系统指南之Linux系统诊断
  • ECS运维指南 之 Linux系统诊断

    • 相关实验场景

    更多
  • 使用计算巢企业应用，一键获取专属的Linux服务器管理软件
  • 部署Linux主机管理系统WDCP
  • 快速配置Linux云服务器
  • 基于Linux命令实现WordPress手动建站
  • Linux系统的安全登录
  • Linux指令入门-文件管理

    • 推荐镜像

    更多
  • mxlinux-iso
  • archlinuxarm
  • archlinuxcn
    • 下一篇
    fs.oss.accessKeyId和fs.oss.accessKeySecret。