c++11条件变量和互斥锁

最新推荐文章于 2024-07-01 17:31:48 发布
最新推荐文章于 2024-07-01 17:31:48 发布
阅读量478 收藏 1
点赞数
分类专栏： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_31872269/article/details/104692785
版权

1:写一个链表

2:如果超过固定大小push阻塞

3:如果链表为空，pop也会阻塞

直接看代码，
main.cpp

#include <stdio.h>
#include <list>
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <condition_variable>

using namespace std;

class listPack
{
public:
	listPack(int maxSize = 10)
	{
		this->_maxSize = maxSize;
	}

	~listPack()
	{
		// 释放链表
	}
	void push(int *mPkt) // 如果链表满，会阻塞
	{
		{
			std::unique_lock<std::mutex> lock{ muxPktVideo };
			conditionMax.wait(lock, [&]()->bool { return listPacks_video.size() < _maxSize; });
		}
		{
			std::unique_lock<std::mutex> lock{ muxPktVideo };

			listPacks_video.push_back(mPkt);
			conditionVideo.notify_one();
		}
	}

	int * pop() // 如果链表空，也会阻塞
	{

		int * t_pkt = 0;
		{
			std::unique_lock<std::mutex> lock{ muxPktVideo };
			//MVideoCap * ptr = this;
			conditionVideo.wait(lock, [&]()->bool { return listPacks_video.size() > 0; });

			t_pkt = listPacks_video.front();
			listPacks_video.pop_front();
			conditionMax.notify_one();
		}
		return t_pkt;
	}

private:

	std::list <int *> listPacks_video;
	std::mutex muxPktVideo;
	std::condition_variable conditionVideo;

	std::condition_variable conditionMax;
	int _maxSize = 10; // 链表的最大长度， 如果等于10 push 的时候会阻塞， 如果等于0 get 的时候会阻塞
};

listPack mListPack(6);

void run(void *prt)
{

	while (1)
	{
		printf("run .... \n");
		int *p = mListPack.pop();

		printf("p[0] = %d \n", p[0]);

		std::this_thread::sleep_for(std::chrono::milliseconds(1000));
		delete p;
	}
}

int main()
{
	std::thread th(run, (void*)(NULL));

	for (int i = 0; i < 100; i++)
	{
		int * p = new int[1];
		*p = i;

		mListPack.push(p);

		printf("hello i = %d \n", i);
	}
	th.join();

}

用模板来写这个链表类似乎更通用一些
main.cpp

#include <stdio.h>
#include <list>
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <condition_variable>

using namespace std;

template<typename T>
class TaskQueueMax {
public:
	TaskQueueMax(int maxSize=10)
	{
		this->_maxSize = maxSize;
	}
	//打入任务至列队
	template<typename C>
	void push_task(C &&task_func) {

		{
			unique_lock<decltype(_mutex)> lock{ _mutex };
			_conditionMax.wait(lock, [&]()->bool { return _queue.size() < _maxSize; }); // suspend and wait ...
		}
		{
			lock_guard<decltype(_mutex)> lock(_mutex);
			_queue.emplace_back(std::forward<C>(task_func));
			_condition.notify_one();
		}

	}
	template<typename C>
	void push_task_first(C &&task_func) {

		{
			unique_lock<decltype(_mutex)> lock{ _mutex };
			_conditionMax.wait(lock, [&]()->bool { return _queue.size() < _maxSize; }); // suspend and wait ...
		}
		{
			lock_guard<decltype(_mutex)> lock(_mutex);
			_queue.emplace_front(std::forward<C>(task_func));
			_condition.notify_one();

		}

	}
	//清空任务列队
	void push_exit(unsigned int n) {

	}
	//从列队获取一个任务，由执行线程执行
	bool get_task(T &tsk) {

		unique_lock<decltype(_mutex)> lock(_mutex);

		_condition.wait(lock, [&]()->bool { return _queue.size() > 0; }); // suspend and wait ...

	 //改成右值引用后性能提升了1倍多！
		tsk = std::move(_queue.front());
		_queue.pop_front();
		_conditionMax.notify_one();
		return true;
	}
	uint64_t size() const {
		lock_guard<decltype(_mutex)> lock(_mutex);
		return _queue.size();
	}
private:

	std::list<T> _queue;
	mutable mutex _mutex;
	std::condition_variable _condition;
	std::condition_variable _conditionMax;
	int _maxSize;

};

TaskQueueMax<int *> mTaskQueue(10);
void run(void *prt)
{
	while (1)
	{
		printf("run .... \n");

		int * p = 0;
		mTaskQueue.get_task(p);
		
		printf("p[0] = %d \n", p[0]);

		std::this_thread::sleep_for(std::chrono::milliseconds(1000));

		delete p;

	}
}
int main()
{
	std::thread th(run, (void*)(NULL));

	for (int i = 0; i < 100; i++)
	{
		int * p = new int[1];
		*p = i;
		mTaskQueue.push_task(p);
		printf("hello i = %d \n", i);


	}

	th.join();

}

不限制链表长度

#include <stdio.h>
#include <list>
#include <iostream>
#include <thread>
#include <mutex>
#include <chrono>
#include <condition_variable>

using namespace std;

template<typename T>
class TaskQueueMax {
public:
	TaskQueueMax()
	{

	}
	//打入任务至列队
	template<typename C>
	void push_task(C &&task_func) {
		{
			lock_guard<decltype(_mutex)> lock(_mutex);
			_queue.emplace_back(std::forward<C>(task_func));
			_condition.notify_one();
		}

	}
	template<typename C>
	void push_task_first(C &&task_func) {

		{
			lock_guard<decltype(_mutex)> lock(_mutex);
			_queue.emplace_front(std::forward<C>(task_func));
			_condition.notify_one();

		}

	}
	//清空任务列队
	void push_exit(unsigned int n) {

	}
	//从列队获取一个任务，由执行线程执行
	bool get_task(T &tsk) {

		unique_lock<decltype(_mutex)> lock(_mutex);

		_condition.wait(lock, [&]()->bool { return _queue.size() > 0; }); // suspend and wait ...
															  //改成右值引用后性能提升了1倍多！
		tsk = std::move(_queue.front());
		_queue.pop_front();
		return true;
	}
	uint64_t size() const {
		lock_guard<decltype(_mutex)> lock(_mutex);
		return _queue.size();
	}
private:

	std::list<T> _queue;
	mutable mutex _mutex;
	std::condition_variable _condition;
};

TaskQueueMax<int *> mTaskQueue;
void run(void *prt)
{
	while (1)
	{
		printf("run .... \n");

		int * p = 0;
		mTaskQueue.get_task(p);

		printf("p[0] = %d \n", p[0]);

		std::this_thread::sleep_for(std::chrono::milliseconds(1000));

		delete p;

	}
}
int main()
{
	std::thread th(run, (void*)(NULL));

	for (int i = 0; i < 100; i++)
	{
		int * p = new int[1];
		*p = i;
		mTaskQueue.push_task(p);
		printf("hello i = %d \n", i);


	}

	th.join();

}
LIZhang2016
关注
专栏目录
[C++] C++11 条件变量
jiang_T的博客
10-27 816
条件变量 C++11 提供了条件变量condition variable用于实现线程间的同步操作，需要包含头文件#include <condition_variable>，并且一般都是与互斥量mutex配合使用。 条件变量的工作方式为： 使用条件变量的线程首先对互斥量加锁 检查某个条件，如果条件不满足，则释放互斥锁量，进入休眠；如果条件满足，则继续执行资源操作，执行完操作后释放互斥量 另外一个线程加锁执行资源操作，使条件满足后，释放互斥量，唤醒等待的线程 具体参考：std::conditio
互斥锁和条件变量 c++11
dchchenghao的专栏
03-08 443
转存失败重新上传取消
【C++11】条件变量
柠檬柠檬C的博客
05-05 607
实现一个同步队列 并且多线程竞争读写。 实例如下： template&lt;typename T&gt; class SyncQueue { public: SyncQueue(int maxSize) : m_maxSize(maxSize) {} void put(const T&amp; value) { std::lock_guard&lt...
c++中互斥锁和条件变量详解
最新发布
qq_54199569的博客
07-01 1041
线程2执行线程函数funcNotify，首先是获得了锁，然后进行cv.notify_all()操作，唤醒线程1，此时线程1已经苏醒，但是线程1并未向下执行，这是由于虽然线程1苏醒了，还没有获得锁不能向下执行，我们让线程1先执行然后cv_.wait(lck)让线程1释放锁，然后线程2获得了锁，执行了自己的任务，然后释放了锁，可以看到线程1仍然在阻塞，并没有看到wait end字样，但是此时锁是可用的，说明，首先让线程id为2，3，4的线程阻塞，然后线程id为5的线程负责唤醒他们，之后线程2，3，4苏醒；
c++11 条件变量
aqwezxc的博客
12-02 1251
条件变量(condition_variable) 条件变量是线程以睡眠的一种形式等待某一条件的发生，所以称之为条件变量。 条件变量利用的是线程共享全局变量来进行同步，所以全局变量一般会被设置为线程睡眠结束开始运行的条件。 Mutex 条件变量一般用于和互斥锁一起使用。在使用条件变量时，需要引用、头文件#include <condition_variable>。condition_variable的对象调用wait函数时，它会通过定义的lock锁定住线程，当前线程被阻塞，不会执行wait下面的
C++11 条件变量
06-05 113
　　C++11中的条件变量提供了用户等待的同步机制，在同步队列的应用中有很大的便利。 　　简单同步队列代码如下(SimpleSyncQueue.h): 1 #ifndef SIMPLESYNCQUEUE_H 2 #define SIMPLESYNCQUEUE_H 3 4 #include <thread> 5 #include <cond...
C++跨平台条件变量和互斥锁封装
10-20
本示例着重讲解如何利用C++标准库中的互斥锁（mutex）和条件变量（condition variable）进行线程同步，并实现跨平台的封装。这些工具是多线程编程中的关键组成部分，用于确保共享资源的安全访问。 首先，让我们了解...
c++使用条件变量与互斥锁来实现读写锁
weixin_44545838的博客
06-09 1083
读写锁与普通的互斥锁不同，它允许多个线程同时持有读锁，并且读取操作不会产生数据竞争，因此多个读取操作可以并发执行，提高了程序的并发性。而在写入操作时，为了保证数据的一致性，只能有一个线程持有写锁，其他的线程需要等待写锁被释放之后再进行操作。在 C++ 中，可以使用标准库中的 std::shared_mutex 类型来实现读写锁。std::shared_mutex 类型提供了 lock_shared、unlock_shared、lock 和 unlock 等方法，可以方便地实现读写锁。
C/C++：互斥锁和条件变量
无聊科技
08-24 7726
       互斥锁、条件变量和信号量是实现线程间同步的三种方式。在多线程程序访问临界资源时，可以对各个线程进行访问限制，每次只允许一个线程访问临界资源。条件变量相当于是互斥锁的一种补充，是线程中的东西，就是等待某一条件的发生，和信号一样。占有临界资源的线程在执行完对于资源的操作后，会发出“信号”，然后其它未占有资源的线程在感知到“信号”后就会抢占资源。 互斥锁的使用 需要的头文件：pthre...
C++多线程中的锁和条件变量使用教程
08-26
C++多线程中的锁和条件变量使用教程 在C++多线程编程中，锁和条件变量是两个非常重要的概念，它们都是用于解决多线程之间的同步和通信问题的。下面我们将详细地介绍锁和条件变量的使用。 一、锁（Mutex） 锁是多...
C++ 11中使用条件变量和锁机制同步线程
OpticalSoliton的专栏
10-09 214
摘自：C++ Concurrency in Action 使用条件变量进行线程同步 ​ #include <thread> #include <mutex> #include <iostream> #include <chrono> #include <condition_variable> #include <queue&...
LINUX锁之条件锁（C++）
qq_36415932的博客
08-16 668
条件变量也叫条件锁。 前面我们提到，互斥量并不是万能的，如果某一线程等待共享资源的某一条件发生，使用互斥量需要频繁加锁和解锁，利用条件变量，条件未发生时，线程阻塞，不占用内核资源，条件发生，唤醒线程。条件变量具体使用方法如下： 1.线程A利用互斥量对共享资源加锁： pthread_mutex_lock(&mutex); 2.线程A从共享资源里寻找条件是否发生（所谓条件，比如，链表...
C++ 锁
g498912529的博客
07-22 4740
总结c++中的锁。本篇文章仅博主个人观点，仅供参考，共同进步，感谢博友支持。
【c++】 多线程编程(二)竞争条件与锁
qq_43145072的博客
12-27 1014
转载自 c++多线程编程 文章目录1. 竞争条件2. 锁定(lock)与解锁(unlock)3. std::lock_guard 类模板4. std::unique_lock 类模板 1. 竞争条件 并发代码中最常见的错误之一就是竞争条件(race condition)。而其中最常见的就是数据竞争(data race)，从整体上来看，所有线程之间共享数据的问题，都是修改数据导致的，如果所有的共享数...
【C++】锁
chi's blog
05-22 3522
互斥锁、条件锁、递归锁、读写锁、自旋锁。其中自旋锁比较特殊，它是一种锁。如果T1正在使用自旋锁，而T2也去申请这个自旋锁，此时T2不但得不到这个自旋锁，而且与互斥锁相反的是，此时运行T2的处理器core2会一直不断地循环检查锁是否可用（自旋锁请求），直到获取到这个自旋锁为止。除自旋锁外，其他的锁都是锁。即假设线程T1获取互斥锁并且正在core1上运行时，此时线程T2也想要获取互斥锁（pthread_mutex_lock），但是由于T1正在使用互斥锁使得T2被阻塞。
七、C++锁的使用
m0_68378610的博客
03-31 630
在std::lock_guard基础上，可以手动对锁进行操作,std::unique_lock比std::lock_guard灵活，但是效率低，占用内存多点。使用std::lock_guard、std::unique_lock方便对线程进行加锁解锁，对std::mutex进行维护使用，不用再手动进行上锁加锁。C++11提出，维护mutex的模板，自动管理互斥锁，构造函数内对锁进行加锁，析构时进行解锁，避免出现死锁、资源泄漏的情况。2.condition_variable.notify_all()通知所有。
C ++ 11多线程–第5部分：使用互斥体修复竞争条件
qq_43690118的博客
08-30 244
翻译来自：C++11 Multithreading – Part 5: Using mutex to fix Race Conditions 在本文中，我们将讨论如何使用互斥锁来保护多线程环境中的共享数据并避免竞争情况。 为了解决多线程环境中的竞争条件，我们需要互斥锁，即每个线程都需要在修改或读取共享数据之前锁定互斥锁，并且在修改数据之后，每个线程都应解锁互斥锁。 std :: mutex 在C ++ 11线程库中，互斥锁位于头文件中。代表互斥量的类是std :: mutex类。 互斥锁有两种重要的方法：
c++ 封装一个条件变量和互斥量的类
06-06
好的，以下是一个简单的 C++ 条件变量和互斥量类的封装示例： ```c++ #include #include class ConditionVariable { public: ConditionVariable() : m_cond(), m_mutex() {} void wait() { std::unique_lock...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值