• Linux生产者消费者模型(POSIX信号量)

    目录

    一.生产者消费者模型

    1.基本概念

    2.模型特点

    3.模型优点 

    二.基于BlockingQueue的生产者消费者模型

    1.基本概念

    2.单生产者、单消费者为例进行模拟实现 

    3.基于计算任务的生产者消费者模型

    三.POSIX信号量

    1.基本概念

    2.信号量函数

    三. 二元信号量模拟实现互斥功能  

    四.基于环形队列的生产者消费者模型

    1.生产者和消费者关心不同资源

    2.需要遵守的两个原则

    3.代码模拟实现

    4.信号量保护环形队列 

    一.生产者消费者模型

    1.基本概念

    • 生产者消费者模式就是通过一个容器来解决生产者和消费者的强耦合问题。
    • 生产者和消费者彼此之间不直接通讯，而通过这个容器来通讯，所以生产者生产完数据之后不用等待消费者处理，直接将生产的数据放到这个容器当中，消费者也不用找生产者要数据，而是直接从这个容器里取数据，这个容器就相当于一个缓冲区，平衡了生产者和消费者的处理能力，这个容器实际上就是用来给生产者和消费者解耦的。

                    

    2.模型特点

    (1)生产者消费者模型是多线程同步与互斥的一个经典场景，其特点如下：

    • 三种关系： 生产者和生产者（互斥关系）、消费者和消费者（互斥关系）、生产者和消费者（互斥关系、同步关系）。
    • 两种角色： 生产者和消费者。（通常由进程或线程承担）
    • 一个交易场所： 通常指的是内存中的一段缓冲区。（可以自己通过某种方式组织起来）

    我们用代码编写生产者消费者模型的时候，本质就是对这三个特点进行维护。

    (2)生产者和生产者、消费者和消费者、生产者和消费者，它们之间为什么会存在互斥关系？

    • 介于生产者和消费者之间的容器可能会被多个执行流同时访问，因此我们需要将该临界资源用互斥锁保护起来。
    • 其中，所有的生产者和消费者都会竞争式的申请锁，因此生产者和生产者、消费者和消费者、生产者和消费者之间都存在互斥关系。

                             

    (3)生产者和消费者之间为什么会存在同步关系？

    • 如果让生产者一直生产，那么当生产者生产的数据将容器塞满后，生产者再生产数据就会生产失败。
    • 反之，让消费者一直消费，那么当容器当中的数据被消费完后，消费者再进行消费就会消费失败。
    • 虽然这样不会造成任何数据不一致的问题，但是这样会引起另一方的饥饿问题，是非常低效的。我们应该让生产者和消费者访问该容器时具有一定的顺序性，比如让生产者先生产，然后再让消费者进行消费。

    注意： 互斥关系保证的是数据的正确性，而同步关系是为了让多线程之间协同起来。

    (4)让消费者和生产者协同工作，合适的时候可能一直运行，生产者和消费者并不会因为要互相等待对方的结果而阻塞，相当于双方可以并发执行.

    (5)为什么要有生产者消费者模型？     本质是用代码进行解耦的过程
                                    

     3.模型优点 

    • 解耦。
    • 支持并发。
    • 支持忙闲不均 (哪边的线程忙可以多分配一些线程)

    (1)如果我们在主函数中调用某一函数，那么我们必须等该函数体执行完后才继续执行主函数的后续代码，因此函数调用本质上是一种紧耦合。

    (2)对应到生产者消费者模型中，函数传参实际上就是生产者生产的过程，而执行函数体实际上就是消费者消费的过程，但生产者只负责生产数据，消费者只负责消费数据，在消费者消费期间生产者可以同时进行生产，因此生产者消费者模型本质是一种松耦合。

                    

                    

    二.基于BlockingQueue的生产者消费者模型

    1.基本概念

    • 在多线程编程中阻塞队列(Blocking Queue)是一种常用于实现生产者和消费者模型的数据结构。
    • 其与普通的队列区别在于，当队列为空时，从队列获取元素的操作将会被阻塞，直到队列中被放入了元素
    • 当队列满时，往队列里存放元 素的操作也会被阻塞，直到有元素被从队列中取出(以上的操作都是基于不同的线程来说的，线程在对阻塞队列进行操作时会被阻塞)

                     

    2.单生产者、单消费者为例进行模拟实现 

    (1) 生产和消费步调一致，生产一个消费一个

    ①BlockQueue.hpp

    1. #pragma oncec
    2.  
    3. #include <iostream>
    4. #include <pthread.h>
    5. #include <queue>
    6. #include <unistd.h>
    7.  
    8. #define NUM 5
    9.  
    10. template<class T>
    11. class BlockQueue
    12. {
    13. private:
    14. 	bool IsFull()
    15. 	{
    16. 		return _q.size() == _cap;
    17. 	}
    18. 	bool IsEmpty()
    19. 	{
    20. 		return _q.empty();
    21. 	}
    22.  
    23. public:
    24. 	BlockQueue(int cap = NUM)
    25. 		: _cap(cap)
    26. 	{
    27. 		pthread_mutex_init(&_mutex, nullptr);
    28. 		pthread_cond_init(&_full, nullptr);
    29. 		pthread_cond_init(&_empty, nullptr);
    30. 	}
    31. 	~BlockQueue()
    32. 	{
    33. 		pthread_mutex_destroy(&_mutex);
    34. 		pthread_cond_destroy(&_full);
    35. 		pthread_cond_destroy(&_empty);
    36. 	}
    37.  
    38. public:
    39. 	//向阻塞队列插入数据（生产者调用）
    40. 	void Push(const T& data)
    41. 	{
    42. 		pthread_mutex_lock(&_mutex);
    43. 		while (IsFull()){
    44. 			//不能进行生产，直到阻塞队列可以容纳新的数据
    45. 			pthread_cond_wait(&_full, &_mutex);
    46. 		}
    47. 		_q.push(data);
    48. 		pthread_cond_signal(&_empty); //唤醒在empty条件变量下等待的消费者线程
    49.  
    50. 		pthread_mutex_unlock(&_mutex);
    51. 	}
    52.  
    53. 	//从阻塞队列获取数据（消费者调用）
    54. 	void Pop(T& data)
    55. 	{
    56. 		pthread_mutex_lock(&_mutex);
    57. 		while (IsEmpty()){
    58. 			//不能进行消费，直到阻塞队列有新的数据
    59. 			pthread_cond_wait(&_empty, &_mutex);
    60. 		}
    61. 		data = _q.front();
    62. 		_q.pop();
    63.  
    64. 		pthread_cond_signal(&_full); //唤醒在full条件变量下等待的生产者线程
    65.  
    66. 		pthread_mutex_unlock(&_mutex);
    67. 	}
    68.  
    69. private:
    70. 	std::queue<T> _q; //阻塞队列
    71. 	int _cap; //阻塞队列容纳数据的最大个数
    72. 	pthread_mutex_t _mutex;
    73. 	pthread_cond_t _full;  
    74. 	pthread_cond_t _empty; 
    75. };

    程序说明:  

    • 由于我们实现的是单生产者、单消费者的生产者消费者模型，因此我们不需要维护生产者和生产者之间的关系，也不需要维护消费者和消费者之间的关系，我们只需要维护生产者和消费者之间的同步与互斥关系即可。
    • 将BlockingQueue当中存储的数据模板化，方便以后需要时进行复用。
    • 这里设置BlockingQueue存储数据的上限为5，当阻塞队列中存储了五组数据时生产者就不能进行生产了，此时生产者就应该被阻塞。
    • 阻塞队列是会被生产者和消费者同时访问的临界资源，因此我们需要用一把互斥锁将其保护起来。
    • 生产者线程要向阻塞队列当中Push数据，前提是阻塞队列里面有空间，若阻塞队列已经满了，那么此时该生产者线程就需要进行等待，直到阻塞队列中有空间时再将其唤醒。
    • 消费者线程要从阻塞队列当中Pop数据，前提是阻塞队列里面有数据，若阻塞队列为空，那么此时该消费者线程就需要进行等待，直到阻塞队列中有新的数据时再将其唤醒。
    • 因此在这里我们需要用到两个条件变量，一个条件变量用来描述队列为空，另一个条件变量用来描述队列已满。当阻塞队列满了的时候，要进行生产的生产者线程就应该在full条件变量下进行等待；当阻塞队列为空的时候，要进行消费的消费者线程就应该在empty条件变量下进行等待。
    • 不论是生产者线程还是消费者线程，它们都是先申请到锁进入临界区后再判断是否满足生产或消费条件的，如果对应条件不满足，那么对应线程就会被挂起。但此时该线程是拿着锁的，为了避免死锁问题，在调用pthread_cond_wait函数时就需要传入当前线程手中的互斥锁，此时当该线程被挂起时就会自动释放手中的互斥锁，而当该线程被唤醒时又会自动获取到该互斥锁。
    • 当生产者生产完一个数据后，意味着阻塞队列当中至少有一个数据，而此时可能有消费者线程正在empty条件变量下进行等待，因此当生产者生产完数据后需要唤醒在empty条件变量下等待的消费者线程。
    • 当消费者消费完一个数据后，意味着阻塞队列当中至少有一个空间，而此时可能有生产者线程正在full条件变量下进行等待，因此当消费者消费完数据后需要唤醒在full条件变量下等待的生产者线程。

                                     

    判断是否满足生产消费条件时不能用if，而应该用while：

    • pthread_cond_wait函数是让当前执行流进行等待的函数，是函数就意味着有可能调用失败，调用失败后该执行流就会继续往后执行,就会出现错误(没有数据还拿，没有空间还放)。
    • 在多消费者的情况下，当生产者生产了一个数据后如果使用pthread_cond_broadcast函数唤醒消费者，就会一次性唤醒多个消费者，但待消费的数据只有一个，此时其他消费者就被伪唤醒了。
    • 为了避免出现上述情况，我们就要让线程被唤醒后再次进行判断，确认是否真的满足生产消费条件，因此这里必须要用while进行判断。
       

    ②main.cc

    1. #include "BlockQueue.hpp"
    2.  
    3. void* Producer(void* arg)
    4. {
    5. 	BlockQueue<int>* bq = (BlockQueue<int>*)arg;
    6. 	//生产者不断进行生产
    7. 	while (true){
    8. 		sleep(1);
    9. 		int data = rand() % 100 + 1;
    10. 		bq->Push(data); //生产数据
    11. 		std::cout << "Producer: " << data << std::endl;
    12. 	}
    13. }
    14.  
    15. void* Consumer(void* arg)
    16. {
    17. 	BlockQueue<int>* bq = (BlockQueue<int>*)arg;
    18. 	//消费者不断进行消费
    19. 	while (true){
    20. 		sleep(1);
    21. 		int data = 0;
    22. 		bq->Pop(data); //消费数据
    23. 		std::cout << "Consumer: " << data << std::endl;
    24. 	}
    25. }
    26.  
    27. int main()
    28. {
    29. 	srand((unsigned int)time(nullptr));//生成随机数
    30.  
    31. 	pthread_t producer, consumer;
    32. 	BlockQueue<int>* bq = new BlockQueue<int>;
    33.  
    34. 	//创建生产者线程和消费者线程
    35. 	pthread_create(&producer, nullptr, Producer, bq);
    36. 	pthread_create(&consumer, nullptr, Consumer, bq);
    37.  
    38. 	//join生产者线程和消费者线程
    39. 	pthread_join(producer, nullptr);
    40. 	pthread_join(consumer, nullptr);
    41.  
    42. 	delete bq;
    43. 	return 0;
    44. }

    程序说明:

    • 阻塞队列要让生产者线程向队列中Push数据，让消费者线程从队列中Pop数据，因此这个阻塞队列必须要让这两个线程同时看到，所以我们在创建生产者线程和消费者线程时，需要将该阻塞队列作为线程执行例程的参数进行传入。

                    

    ③结果 : 生产者是每隔一秒生产一个数据，所以消费者是每隔一秒消费一个数据，因此运行代码后我们可以看到生产者和消费者的执行步调是一致的。

            

     (2)生产快，消费慢

    ①代码: 只需要改变main.cc中的执行函数

    1. void* Producer(void* arg)
    2. {
    3. 	BlockQueue<int>* bq = (BlockQueue<int>*)arg;
    4. 	//生产者不断进行生产
    5. 	while (true){
    6. 		int data = rand() % 100 + 1;
    7. 		bq->Push(data); //生产数据
    8. 		std::cout << "Producer: " << data << std::endl;
    9. 	}
    10. }
    11.  
    12. void* Consumer(void* arg)
    13. {
    14. 	BlockQueue<int>* bq = (BlockQueue<int>*)arg;
    15. 	//消费者不断进行消费
    16. 	while (true){
    17. 		sleep(1);
    18. 		int data = 0;
    19. 		bq->Pop(data); //消费数据
    20. 		std::cout << "Consumer: " << data << std::endl;
    21. 	}
    22. }

     ②结果: 生产者生产的很快，运行后一瞬间生产者就将阻塞队列打满了，此时生产者想要再进行生产就只能在full条件变量下进行等待，直到消费者消费完一个数据后，生产者才会被唤醒进而继续进行生产，生产者生产完一个数据后又会进行等待，因此后续生产者和消费者的步调又变成一致的了 ; 顺序消费。

                                                            

    (3)生产慢，消费快

    ①代码

    1. void* Producer(void* arg)
    2. {
    3. 	BlockQueue<int>* bq = (BlockQueue<int>*)arg;
    4. 	//生产者不断进行生产
    5. 	while (true){
    6. 		sleep(1);
    7. 		int data = rand() % 100 + 1;
    8. 		bq->Push(data); //生产数据
    9. 		std::cout << "Producer: " << data << std::endl;
    10. 	}
    11. }
    12. void* Consumer(void* arg)
    13. {
    14. 	BlockQueue<int>* bq = (BlockQueue<int>*)arg;
    15. 	//消费者不断进行消费
    16. 	while (true){
    17. 		int data = 0;
    18. 		bq->Pop(data); //消费数据
    19. 		std::cout << "Consumer: " << data << std::endl;
    20. 	}
    21. }

    ②结果 : 虽然消费者消费的很快，但一开始阻塞队列中是没有数据的，因此消费者只能在empty条件变量下进行等待，直到生产者生产完一个数据后，消费者才会被唤醒进而进行消费，消费者消费完这一个数据后又会进行等待，因此生产者和消费者的步调就是一致的。

                    

    (4) 生产/消费超过一定高低水位线再通知另一方

    ①代码 : 生产者生产快不sleep，消费者消费慢sleep

    1. //向阻塞队列插入数据（生产者调用）
    2. void Push(const T& data)
    3. {
    4. 	pthread_mutex_lock(&_mutex);
    5. 	while (IsFull()){
    6. 		//不能进行生产，直到阻塞队列可以容纳新的数据
    7. 		pthread_cond_wait(&_full, &_mutex);
    8. 	}
    9. 	_q.push(data);
    10.  
    11.     //高低水位线
    12. 	if (_q.size() >= _cap / 2){
    13. 		pthread_cond_signal(&_empty); //唤醒在empty条件变量下等待的消费者线程
    14. 	}
    15.  
    16. 	pthread_mutex_unlock(&_mutex);
    17. }
    18.  
    19. //从阻塞队列获取数据（消费者调用）
    20. void Pop(T& data)
    21. {
    22. 	pthread_mutex_lock(&_mutex);
    23. 	while (IsEmpty()){
    24. 		//不能进行消费，直到阻塞队列有新的数据
    25. 		pthread_cond_wait(&_empty, &_mutex);
    26. 	}
    27. 	data = _q.front();
    28. 	_q.pop();
    29.  
    30.     //高低水位线
    31. 	if (_q.size() <= _cap / 2){
    32. 		pthread_cond_signal(&_full); //唤醒在full条件变量下等待的生产者线程
    33. 	}
    34.  
    35. 	pthread_mutex_unlock(&_mutex);
    36. }

    ②结果 :运行代码后生产者还是一瞬间将阻塞队列打满后进行等待，但此时不是消费者消费一个数据就唤醒生产者线程，而是当阻塞队列当中的数据小于队列容器的一半时，才会唤醒生产者线程进行生产。

                    

    3.基于计算任务的生产者消费者模型

    (1)代码 

    ①Task.hpp : 定义一个Task类，这个类当中包含一个Run成员函数，该函数代表着如何让消费者处理拿到的数据。

    1. #pragma once
    2. #include <iostream>
    3.  
    4. class Task
    5. {
    6. public:
    7. 	Task(int x = 0, int y = 0, int op = 0)
    8. 		: _x(x), _y(y), _op(op)
    9. 	{}
    10. 	~Task()
    11. 	{}
    12.  
    13. 	void Run()
    14. 	{
    15. 		int result = 0;
    16. 		switch (_op)
    17. 		{
    18. 		case '+':
    19. 			result = _x + _y;
    20. 			break;
    21. 		case '-':
    22. 			result = _x - _y;
    23. 			break;
    24. 		case '*':
    25. 			result = _x * _y;
    26. 			break;
    27. 		case '/':
    28. 			if (_y == 0){
    29. 				std::cout << "Warning: div zero!" << std::endl;
    30. 				result = -1;
    31. 			}
    32. 			else{
    33. 				result = _x / _y;
    34. 			}
    35. 			break;
    36. 		case '%':
    37. 			if (_y == 0){
    38. 				std::cout << "Warning: mod zero!" << std::endl;
    39. 				result = -1;
    40. 			}
    41. 			else{
    42. 				result = _x % _y;
    43. 			}
    44. 			break;
    45. 		default:
    46. 			std::cout << "error operation!" << std::endl;
    47. 			break;
    48. 		}
    49. 		std::cout << _x << _op << _y << "=" << result << std::endl;
    50. 	}
    51.  
    52. private:
    53. 	int _x;
    54. 	int _y;
    55. 	char _op;
    56. };

    ②main.cc : 对线程执行函数稍作修改, 此时生产者放入阻塞队列的数据就是一个Task对象，而消费者从阻塞队列拿到Task对象后，就可以用该对象调用Run成员函数进行数据处理。

    1. void* Producer(void* arg)
    2. {
    3. 	BlockQueue<Task>* bq = (BlockQueue<Task>*)arg;
    4. 	const char* arr = "+-*/%";
    5. 	//生产者不断进行生产
    6. 	while (true){
    7. 		int x = rand() % 100;
    8. 		int y = rand() % 100;
    9. 		char op = arr[rand() % 5];
    10. 		Task t(x, y, op);
    11. 		bq->Push(t); //生产数据
    12. 		std::cout << "producer task done" << std::endl;
    13. 	}
    14. }
    15.  
    16. void* Consumer(void* arg)
    17. {
    18. 	BlockQueue<Task>* bq = (BlockQueue<Task>*)arg;
    19. 	//消费者不断进行消费
    20. 	while (true){
    21. 		sleep(1);
    22. 		Task t;
    23. 		bq->Pop(t); //消费数据
    24. 		t.Run(); //处理数据
    25. 	}
    26. }

                     

    (2)结果 : 运行代码，当阻塞队列被生产者打满后消费者被唤醒，此时消费者在消费数据时执行的就是计算任务，当阻塞队列当中的数据被消费到低水位线时又会唤醒生产者进行生产。

                    

     (3)小结

    我们想让生产者消费者模型处理某一种任务时，大体的框架已经搭建好了，就只需要提供对应的Task类，然后让该Task类提供一个对应的Run成员函数告诉我们应该如何处理这个任务即可

                                    

                    

            

                    

    三.POSIX信号量

    1.基本概念

    • 信号量（信号灯）本质是一个计数器，是描述临界资源中资源数目的计数器，信号量能够更细粒度的对临界资源进行管理。
    • 每个执行流在进入临界区之前都应该先申请信号量，申请成功就有了操作特定的临界资源的权限，当操作完毕后就应该释放信号量
    • 信号量存在的价值 : 1.进行同步与互斥    2.更细粒度的临界资源的管理
       

    (1)为什么要有信号量？ 提高效率

    • 当我们仅用一个互斥锁对临界资源进行保护时，相当于我们将这块临界资源看作一个整体，同一时刻只允许一个执行流对这块临界资源进行访问。
    • 如果我们将这块临界资源再分割为多个区域，当多个执行流需要访问临界资源时，这些执行流访问的是临界资源的不同区域，那么我们可以让这些执行流同时访问临界资源的不同区域，此时不会出现数据不一致等问题。        

    (2)信号量的PV操作：

    • P操作：我们将申请信号( count-- )量称为P操作，申请信号量的本质就是申请获得临界资源中某块资源的使用权限，当申请成功时临界资源中资源的数目应该减一，因此P操作的本质就是让计数器减一。
    • V操作：我们将释放信号量( count++ )称为V操作，释放信号量的本质就是归还临界资源中某块资源的使用权限，当释放成功时临界资源中资源的数目就应该加一，因此V操作的本质就是让计数器加一。

    (3)PV操作必须是原子操作

    • 多个执行流为了访问临界资源会竞争式的申请信号量，因此信号量是会被多个执行流同时访问的，也就是说信号量本质也是临界资源。
    • 但信号量本质就是用于保护临界资源的，我们不可能再用信号量去保护信号量，所以信号量的PV操作必须是原子操作。
    • 内存当中变量的++、--操作并不是原子操作，因此信号量不可能只是简单的对一个全局变量进行++、--操作。

    (4)申请信号量失败被挂起等待

    • 当执行流在申请信号量时，可能此时信号量的值为0，也就是说信号量描述的临界资源已经全部被申请了，此时该执行流就应该在该信号量的等待队列当中进行等待，直到有信号量被释放时再被唤醒。
    •  信号量的本质是计数器，但不意味着只有计数器，信号量还包括一个等待队列。

    (5)信号量结构的大致理解伪代码:

                     

    2.信号量函数

    (1) 初始化

    函数 :  int sem_init(sem_t *sem, int pshared, unsigned int value);

    参数：

    • sem：需要初始化的信号量。
    • pshared：传入0值表示线程间共享，传入非零值表示进程间共享(常用0)
    • value：信号量的初始值（计数器的初始值）。

    返回值： 初始化信号量成功返回0，失败返回-1。


    注意： POSIX信号量和System V信号量作用相同，都是用于同步操作，达到无冲突的访问共享资源目的，但POSIX信号量可以用于线程间同步。

    (2)销毁

    函数 : int sem_destroy(sem_t *sem);
     

    参数： sem：需要销毁的信号量。

    返回值：销毁信号量成功返回0，失败返回-1。

    (3)等待信号量（申请信号量 ,P()）

    函数 : int sem_wait(sem_t *sem);


    参数：sem：需要等待的信号量。


    返回值：

    • 等待信号量成功返回0，信号量的值减一
    • 等待信号量失败返回-1，信号量的值保持不变

    (4)发布信号量（释放信号量,V()）

    函数 : int sem_post(sem_t *sem);

    参数：sem：需要发布的信号量。


    返回值：

    • 发布信号量成功返回0，信号量的值加一
    • 发布信号量失败返回-1，信号量的值保持不变

            

                    

                    

    三. 二元信号量模拟实现互斥功能  

    • 信号量本质是一个计数器，如果将信号量的初始值设置为1，那么此时该信号量叫做二元信号量。
    • 信号量的初始值为1，说明信号量所描述的临界资源只有一份，此时信号量的作用基本等价于互斥锁。

    示例，实现一个多线程抢票系统，使用二元信号量模拟实现多线程互斥,，让每个线程在访问全局变量tickets之前先申请信号量，访问完毕后再释放信号量，此时二元信号量就达到了互斥的效果。

    1.代码

    1. #include <iostream>
    2. #include <string>
    3. #include <unistd.h>
    4. #include <pthread.h>
    5. #include <semaphore.h>
    6.  
    7. class Sem{
    8. public:
    9. 	Sem(int num)
    10. 	{
    11. 		sem_init(&_sem, 0, num);
    12. 	}
    13. 	~Sem()
    14. 	{
    15. 		sem_destroy(&_sem);
    16. 	}
    17. 	void P()
    18. 	{
    19. 		sem_wait(&_sem);
    20. 	}
    21. 	void V()
    22. 	{
    23. 		sem_post(&_sem);
    24. 	}
    25. private:
    26. 	sem_t _sem;
    27. };
    28.  
    29.  
    30. Sem sem(1); //二元信号量
    31. int tickets = 1000;
    32.  
    33. void* TicketGrabbing(void* arg)
    34. {
    35. 	std::string name = (char*)arg;
    36. 	while (true){
    37. 		sem.P();
    38. 		if (tickets > 0){
    39. 			usleep(1000);
    40. 			std::cout << name << " get a ticket, tickets left: " << --tickets << std::endl;
    41. 			sem.V();
    42. 		}
    43. 		else{
    44. 			sem.V();
    45. 			break;
    46. 		}
    47. 	}
    48. 	std::cout << name << " quit..." << std::endl;
    49. 	pthread_exit((void*)0);
    50. }
    51.  
    52. int main()
    53. {
    54. 	pthread_t tid1, tid2, tid3, tid4;
    55. 	pthread_create(&tid1, nullptr, TicketGrabbing, (void*)"thread 1");
    56. 	pthread_create(&tid2, nullptr, TicketGrabbing, (void*)"thread 2");
    57. 	pthread_create(&tid3, nullptr, TicketGrabbing, (void*)"thread 3");
    58. 	pthread_create(&tid4, nullptr, TicketGrabbing, (void*)"thread 4");
    59. 	
    60. 	pthread_join(tid1, nullptr);
    61. 	pthread_join(tid2, nullptr);
    62. 	pthread_join(tid3, nullptr);
    63. 	pthread_join(tid4, nullptr);
    64. 	return 0;
    65. }

    2.结果 : 未出现数据不一致问题 

                    

                    

                            

    四.基于环形队列的生产者消费者模型

    1.生产者和消费者关心不同资源

    (1)生产者关注的是空间资源，消费者关注的是数据资源

    • 生产者关注的是环形队列当中是否有空间（blank），只要有空间生产者就可以进行生产。
    • 消费者关注的是环形队列当中是否有数据（data），只要有数据消费者就可以进行消费。

             

    (2)blank_sem和data_sem的初始值设置

    现在我们用信号量来描述环形队列当中的空间资源（blank_sem）和数据资源（data_sem），在我们初始信号量时给它们设置的初始值是不同的：

    • blank_sem的初始值我们应该设置为环形队列的容量，因为刚开始时环形队列当中全是空间。
    • data_sem的初始值我们应该设置为0，因为刚开始时环形队列当中没有数据。

                     

    (3)生产者和消费者申请和释放资源

    ①生产者申请空间资源，释放数据资源

    对于生产者来说，生产者每次生产数据前都需要先申请blank_sem：

    • 如果blank_sem的值不为0，则信号量申请成功，此时生产者可以进行生产操作。
    • 如果blank_sem的值为0，则信号量申请失败，此时生产者需要在blank_sem的等待队列下进行阻塞等待，直到环形队列当中有新的空间后再被唤醒。

    当生产者生产完数据后，应该释放data_sem：

    • 虽然生产者在进行生产前是对blank_sem进行的P操作，但是当生产者生产完数据，应该对data_sem进行V操作而不是blank_sem。
    • 生产者在生产数据前申请到的是blank位置，当生产者生产完数据后，该位置当中存储的是生产者生产的数据，在该数据被消费者消费之前，该位置不再是blank位置，而应该是data位置。
    • 当生产者生产完数据后，意味着环形队列当中多了一个data位置，因此我们应该对data_sem进行V操作。

                             

    ②消费者申请数据资源，释放空间资源

    对于消费者来说，消费者每次消费数据前都需要先申请data_sem：

    • 如果data_sem的值不为0，则信号量申请成功，此时消费者可以进行消费操作。
    • 如果data_sem的值为0，则信号量申请失败，此时消费者需要在data_sem的等待队列下进行阻塞等待，直到环形队列当中有新的数据后再被唤醒。

    当消费者消费完数据后，应该释放blank_sem：

    • 虽然消费者在进行消费前是对data_sem进行的P操作，但是当消费者消费完数据，应该对blank_sem进行V操作而不是data_sem。
    • 消费者在消费数据前申请到的是data位置，当消费者消费完数据后，该位置当中的数据已经被消费过了，再次被消费就没有意义了，为了让生产者后续可以在该位置生产新的数据，我们应该将该位置算作blank位置，而不是data位置。
    • 当消费者消费完数据后，意味着环形队列当中多了一个blank位置，因此我们应该对blank_sem进行V操作。

                     

     2.需要遵守的两个原则

    (1)生产者和消费者不能对同一个位置进行访问(互斥)

    • 如果生产者和消费者访问的是环形队列当中的同一个位置，那么此时生产者和消费者就相当于同时对这一块临界资源进行了访问，这当然是不允许的。
    • 而如果生产者和消费者访问的是环形队列当中的不同位置，那么此时生产者和消费者是可以同时进行生产和消费的，此时不会出现数据不一致等问题。

    (2)无论是生产者还是消费者，都不应该将对方套一个圈以上(格子的数量有限)

    • 生产者从消费者的位置开始一直按顺时针方向进行生产，如果生产者生产的速度比消费者消费的速度快，那么当生产者绕着消费者生产了一圈数据后再次遇到消费者，此时生产者就不应该再继续生产了，因为再生产就会覆盖还未被消费者消费的数据。
    • 同理，消费者从生产者的位置开始一直按顺时针方向进行消费，如果消费者消费的速度比生产者生产的速度快，那么当消费者绕着生产者消费了一圈数据后再次遇到生产者，此时消费者就不应该再继续消费了，因为再消费就会消费到缓冲区中保存的废弃数据。
       

                             

    3.代码模拟实现

    (1) 代码

    ①RingQueue.hpp

    1. #pragma once
    2.  
    3. #include <iostream>
    4. #include <unistd.h>
    5. #include <pthread.h>
    6. #include <semaphore.h>
    7. #include <vector>
    8.  
    9. #define NUM 10
    10.  
    11. template<class T>
    12. class RingQueue
    13. {
    14. private:
    15. 	//P操作
    16. 	void P(sem_t& s)
    17. 	{
    18. 		sem_wait(&s);
    19. 	}
    20. 	//V操作
    21. 	void V(sem_t& s)
    22. 	{
    23. 	    sem_post(&s);
    24. 	}
    25. public:
    26. 	RingQueue(int cap = NUM)
    27. 		: _cap(cap), _p_pos(0), _c_pos(0)
    28. 	{
    29. 		_q.resize(_cap);
    30. 		sem_init(&_blank_sem, 0, _cap); //blank_sem初始值设置为环形队列的容量
    31. 		sem_init(&_data_sem, 0, 0); //data_sem初始值设置为0
    32. 	}
    33. 	~RingQueue()
    34. 	{
    35. 	sem_destroy(&_blank_sem);
    36. 	sem_destroy(&_data_sem);
    37. 	}
    38.  
    39. public:
    40. 	//向环形队列插入数据（生产者调用）
    41. 	void Push(const T& data)
    42. 	{
    43. 		P(_blank_sem); //生产者关注空间资源
    44. 		_q[_p_pos] = data;
    45. 		V(_data_sem); //生产
    46.  
    47. 		//更新下一次生产的位置
    48. 		_p_pos++;
    49. 		_p_pos %= _cap;
    50. 	}
    51.  
    52. 	//从环形队列获取数据（消费者调用）
    53. 	void Pop(T& data)
    54. 	{
    55. 		P(_data_sem); //消费者关注数据资源
    56. 		data = _q[_c_pos];
    57. 		V(_blank_sem);
    58.  
    59. 		//更新下一次消费的位置
    60. 		_c_pos++;
    61. 		_c_pos %= _cap;
    62. 	}
    63.  
    64. private:
    65. 	std::vector<T> _q; //环形队列
    66. 	int _cap; //环形队列的容量上限
    67. 	int _p_pos; //生产位置
    68. 	int _c_pos; //消费位置
    69. 	sem_t _blank_sem; //描述空间资源
    70. 	sem_t _data_sem; //描述数据资源
    71. };

    程序解释: 

    • 当不设置环形队列的大小时，我们默认将环形队列的容量上限设置为10。
    • 代码中的RingQueue是用vector实现的，生产者每次生产的数据放到vector下标为p_pos的位置，消费者每次消费的数据来源于vector下标为c_pos的位置。
    • 生产者每次生产数据后p_pos都会进行++，标记下一次生产数据的存放位置，++后的下标会与环形队列的容量进行取模运算，实现“环形”的效果。
    • 消费者每次消费数据后c_pos都会进行++，标记下一次消费数据的来源位置，++后的下标会与环形队列的容量进行取模运算，实现“环形”的效果。
    • p_pos只会由生产者线程进行更新，c_pos只会由消费者线程进行更新，对这两个变量访问时不需要进行保护，因此代码中将p_pos和c_pos的更新放到了V操作之后，就是为了尽量减少临界区的代码 , 提高效率
    • 这里也可以设置高低水位线，数据/空格子数量达到一定程度再消费
       

    ②main.cc实现单生产者，单消费者模型

    1. #include "RingQueue.hpp"
    2.  
    3. void* Producer(void* arg)
    4. {
    5. 	RingQueue<int>* rq = (RingQueue<int>*)arg;
    6. 	while (true){
    7. 		sleep(1);
    8. 		int data = rand() % 100 + 1;
    9. 		rq->Push(data);
    10. 		std::cout << "Producer: " << data << std::endl;
    11. 	}
    12. }
    13.  
    14. void* Consumer(void* arg)
    15. {
    16. 	RingQueue<int>* rq = (RingQueue<int>*)arg;
    17. 	while (true){
    18. 		sleep(1);
    19. 		int data = 0;
    20. 		rq->Pop(data);
    21. 		std::cout << "Consumer: " << data << std::endl;
    22. 	}
    23. }
    24.  
    25. int main()
    26. {
    27. 	srand((unsigned int)time(nullptr));
    28.  
    29. 	pthread_t producer, consumer;
    30. 	RingQueue<int>* rq = new RingQueue<int>;
    31. 	pthread_create(&producer, nullptr, Producer, rq);
    32. 	pthread_create(&consumer, nullptr, Consumer, rq);
    33. 	
    34. 	pthread_join(producer, nullptr);
    35. 	pthread_join(consumer, nullptr);
    36. 	delete rq;
    37. 	return 0;
    38. }
    •  环形队列要让生产者线程向队列中Push数据，让消费者线程从队列中Pop数据，因此这个环形队列必须要让这两个线程同时看到，所以我们在创建生产者线程和消费者线程时，需要将环形队列作为线程执行例程的参数进行传入

                     

    (2)结果

    ①生产者消费者同步

    ②生产快消费慢

    • 生产者生产的很快，运行代码后一瞬间生产者就将环形队列打满了，此时生产者想要再进行生产，但空间资源已经为0了，于是生产者只能在blank_sem的等待队列下进行阻塞等待，直到由消费者消费完一个数据后对blank_sem进行了V操作，生产者才会被唤醒进而继续进行生产。
    • 但由于生产者的生产速度很快，生产者生产完一个数据后又会进行等待，因此后续生产者和消费者的步调又变成一致的了。

                     

    ③生产慢消费快 

    • 虽然消费者消费的很快，但一开始环形队列当中的数据资源为0，因此消费者只能在data_sem的等待队列下进行阻塞等待，直到生产者生产完一个数据后对data_sem进行了V操作，消费者才会被唤醒进而进行消费。
    • 但由于消费者的消费速度很快，消费者消费完一个数据后又会进行等待，因此后续生产者和消费者的步调又变成一致的了。

                                            

    4.信号量保护环形队列 

    (1)在blank_sem和data_sem两个信号量的保护后，该环形队列中不可能会出现数据不一致的问题。

    ①因为只有当生产者和消费者指向同一个位置并访问时，才会导致数据不一致的问题，而此时生产者和消费者在对环形队列进行写入或读取数据时，只有两种情况会指向同一个位置：

    • 环形队列为空时
    • 环形队列为满时

    ②但是在这两种情况下，生产者和消费者不会同时对环形队列进行访问：

    • 当环形队列为空的时，消费者一定不能进行消费，因为此时数据资源为0
    • 当环形队列为满的时，生产者一定不能进行生产，因为此时空间资源为0

                             

    (2)当环形队列为空和满时，我们已经通过信号量保证了生产者和消费者的串行化过程。而除了这两种情况之外，生产者和消费者指向的都不是同一个位置，因此该环形队列当中不可能会出现数据不一致的问题。并且大部分情况下生产者和消费者指向并不是同一个位置，因此大部分情况下该环形队列可以让生产者和消费者并发的执行.
     

  • 相关阅读:
    Linux CentOS 安装配置 MariaDB
    BAT 面试题集合
    Java nio 的线程通信机制线程通信Pipe
    【Spring篇】IOC/DI配置管理第三方bean
    4.5 x64dbg 探索钩子劫持技术
    ABB码垛机器人IRB260通讯板维修
    [算法刷题笔记]二叉树练习(2):对称二叉树有关的练习
    存储基础知识入门
    【Seata】03 - Seata AT 模式全局锁相关知识简单整理
    [PAT练级笔记] 44 Basic Level 1044 火星数字
  • 原文地址：https://blog.csdn.net/m0_52169086/article/details/125585654