BlockingQueue C++实现

最新推荐文章于 2024-08-13 14:44:58 发布
最新推荐文章于 2024-08-13 14:44:58 发布
阅读量543 收藏 1
点赞数
分类专栏： C++ 文章标签： c/c++
本文介绍了一种使用Windows内核对象实现的阻塞队列，包括两种不同的设计方案，并详细展示了其核心代码。优化后的方案引入了CMonitor类来管理同步信号，提高了线程间的通信效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

 

// BlockingQueue.h: interface for the CBlockingQueue class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_BLOCKINGQUEUE_H__E6C614E8_4A5D_4D18_A38D_845018DA75B6__INCLUDED_)
#define AFX_BLOCKINGQUEUE_H__E6C614E8_4A5D_4D18_A38D_845018DA75B6__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <windows.h>
#include <LIST>
#include <vector>
#include <STRING>
using namespace std;

class CBlockingQueue
{
public:
	CBlockingQueue(int size);
	virtual ~CBlockingQueue();
private:
	CBlockingQueue();
	HANDLE m_MssageNullEvent;
	HANDLE m_synSignal;
	int m_size;
	list<string> m_msgs;
public:
		string Dequeue();
		void Enqueue(string msg);
};

#endif // !defined(AFX_BLOCKINGQUEUE_H__E6C614E8_4A5D_4D18_A38D_845018DA75B6__INCLUDED_)

 

 

 

 

// BlockingQueue.cpp: implementation of the CBlockingQueue class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "BlockingQueue.h"
#include <afxcom_.h>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBlockingQueue::CBlockingQueue()
{

}

CBlockingQueue::CBlockingQueue(int ssize)
{
	m_size=ssize;
	m_synSignal=CreateSemaphore(NULL,1,1,"m_synSignal");
	m_MssageNullEvent=CreateEvent(NULL,TRUE,TRUE,"m_MssageNullEvent");
}

CBlockingQueue::~CBlockingQueue()
{
	
}
string CBlockingQueue::Dequeue()
{
	string msg="";
	WaitForSingleObject(m_synSignal,INFINITE);
	while(0==m_msgs.size())
	{
		bool breset=ResetEvent(m_MssageNullEvent);
		ReleaseSemaphore(m_synSignal,1,NULL);
		DWORD nret=WaitForSingleObject(m_MssageNullEvent,INFINITE);
		//ASSERT(WAIT_TIMEOUT!=);	
	}
	string temp=*m_msgs.begin();
	m_msgs.pop_front();
	SetEvent(m_MssageNullEvent);
	ReleaseSemaphore(m_synSignal,1,NULL);
	
	return temp;
}

void CBlockingQueue::Enqueue(string msg)
{
	WaitForSingleObject(m_synSignal,INFINITE);
	int a=m_msgs.size();
	while(m_size==m_msgs.size())
	{
		bool bret=	ResetEvent(m_MssageNullEvent);
		ReleaseSemaphore(m_synSignal,1,NULL);
		DWORD nret=	WaitForSingleObject(m_MssageNullEvent,INFINITE);	
	}
	m_msgs.push_back(msg);
	ReleaseSemaphore(m_synSignal,1,NULL);
	if (1==m_msgs.size())
		SetEvent(m_MssageNullEvent);
}

 

 以上不具有普遍性，更合理的设计如下：

 

将  同步内核对象抽象出来 成为 CMonitor

 

// Monitor.h: interface for the CMonitor class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_MONITOR_H__26A4800D_6F3C_41BF_97AC_1D20860517AC__INCLUDED_)
#define AFX_MONITOR_H__26A4800D_6F3C_41BF_97AC_1D20860517AC__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <windows.h>

class CMonitor 
{

	

public:
	CMonitor();
	virtual ~CMonitor();


private:
	HANDLE m_h[2];
	DWORD m_lastThreadId;
public:
	void wait(DWORD timeout);
	bool pulse();
	void Enter();
	void Exit();
	


};

#endif // !defined(AFX_MONITOR_H__26A4800D_6F3C_41BF_97AC_1D20860517AC__INCLUDED_)

 

// Monitor.cpp: implementation of the CMonitor class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Monitor.h"
#include <exception>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CMonitor::CMonitor()
{
	m_h[0]=CreateEvent(NULL,TRUE,TRUE,"h1");
	m_h[1]=CreateEvent(NULL,TRUE,TRUE,"h2");
	m_lastThreadId=0;
}

CMonitor::~CMonitor()
{

}

void CMonitor::Enter()
{
	m_lastThreadId=::GetCurrentThreadId();	
	WaitForSingleObject(m_h[0],INFINITE);//ResetEvent();
}

void CMonitor::Exit()
{
	m_lastThreadId=NULL;
	SetEvent(m_h[0]);
	SetEvent(m_h[1]);
}

bool CMonitor::pulse()
{
	if (!(m_lastThreadId!=NULL || m_lastThreadId!=::GetCurrentThreadId()))
	{
		throw exception("The wait could only be excuted by the monitor owner!");
	}
	SetEvent(m_h[1]);

	return true;
}

void CMonitor::wait( DWORD timeout )
{
	if (!(m_lastThreadId!=NULL || m_lastThreadId!=::GetCurrentThreadId()))
	{
		throw exception("The wait could only be excuted by the monitor owner!");
	}
	m_lastThreadId=NULL;
	ResetEvent(m_h[1]);
	WaitForSingleObject(m_h[1],timeout);
	SetEvent(m_h[0]);
}

 

 

那么新的 BlockingQueue代码如下：

 

// BlockingQueue.h: interface for the CBlockingQueue class.
//
//////////////////////////////////////////////////////////////////////

#if !defined(AFX_BLOCKINGQUEUE_H__E6C614E8_4A5D_4D18_A38D_845018DA75B6__INCLUDED_)
#define AFX_BLOCKINGQUEUE_H__E6C614E8_4A5D_4D18_A38D_845018DA75B6__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include <windows.h>
#include <LIST>
#include <vector>
#include <STRING>
#include "Monitor.h"
using namespace std;

class CBlockingQueue
{
public:
	CBlockingQueue(int size);
	virtual ~CBlockingQueue();
private:
	CBlockingQueue();
	int m_size;
	list<string> m_msgs;

	CMonitor m_monitor;
public:
		string Dequeue();
		void Enqueue(string msg);
};

#endif // !defined(AFX_BLOCKINGQUEUE_H__E6C614E8_4A5D_4D18_A38D_845018DA75B6__INCLUDED_)

 

 

// BlockingQueue.cpp: implementation of the CBlockingQueue class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "BlockingQueue.h"
#include <afxcom_.h>

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CBlockingQueue::CBlockingQueue()
{

}

CBlockingQueue::CBlockingQueue(int ssize)
{
	m_size=ssize;
}

CBlockingQueue::~CBlockingQueue()
{
	
}
string CBlockingQueue::Dequeue()
{
	string msg="";

	m_monitor.Enter();
	{
		while(0==m_msgs.size())
		{
			m_monitor.wait(INFINITE);
		}
		msg=*m_msgs.begin();
		m_msgs.pop_front();
		if ((m_size-1)==m_msgs.size())
			m_monitor.pulse();
	}
	m_monitor.Exit();

	return msg;
}

void CBlockingQueue::Enqueue(string msg)
{
	m_monitor.Enter();
	{
		int a=m_msgs.size();
		while(m_size==m_msgs.size())
		{
			m_monitor.wait(INFINITE);
		}
		m_msgs.push_back(msg);
		if (1==m_msgs.size())
			m_monitor.pulse();
	}
	m_monitor.Exit();
}

 

c++ 实现 blocking queue
hatlonely的专栏
11-27 906
阻塞队列就是多线程线程安全的队列，在多线程场景下经常用到，c++ 标准库里面没有提供阻塞队列，boost 中有提供，生成环境下可以使用 blocking queue 实现 主要设计思路： 使用 std::vector 实现一个环形队列，使用两个指针 start 和 end 来标识起止位置，push 的时候在 end 处插入，pop 的时候直接 start 指针往后移即可 使用 std::cond...
c++ 实现的BlockingQueue
yinchuofan1985的专栏
10-16 1663
1、BlockingQueue类 #include "thread/Critical.h" #include "thread/Codition.h" #include "thread/Lock.h" #include using namespace std; const unsigned int DEFAULT_MAX_SIZE = 100; template class Blocking
一个C++的BlockingQueue实现
Raphaelliu的专栏
02-18 2256
<br />原文在<br />http://www.justsoftwaresolutions.co.uk/threading/implementing-a-thread-safe-queue-using-condition-variables.html<br />template<typename Data> class concurrent_queue { private: std::queue<Data> the_queue; mutable boost::mutex the
C++写的跨平台BlockingQueue
02-07
类似java BlockingQueue，C++写的，支持Windows与Linux。
C++并发实战：面试题4：生产者消费者试题blocking queue
liuxuejiang158的专栏
03-27 6040
生产者消费者问题 这是一个非常经典的多线程题目，题目大意如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，所有生产者和消费者都是异步方式运行的，但它们必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经装
C++11 线程安全的BlockingQueue实现
大黄鸭
09-20 8056
C++11 BlockingQueue
C++实现跨平台BlockingQueue的设计与应用
在实际的C++项目中实现一个跨平台的BlockingQueue，将结合上述跨平台编程技巧和BlockingQueue实现要点。例如，可以在Linux和Windows环境下共享大部分代码，对于需要系统特定处理的代码部分，则通过条件编译进行区分...
C++ 实现一个简易的阻塞队列
ChaoQun
10-03 2358
阻塞队列是多线程中常用的数据结构，对于实现多线程之间的数据交换、同步等有很大作用。 阻塞队列常用于生产者和消费者的场景，生产者是向队列里添加元素的线程，消费者是从队列里取元素的线程。简而言之，阻塞队列是生产者用来存放元素、消费者获取元素的容器。 考虑下，这样一个多线程模型，程序有一个主线程 master 和一些 worker 线程，master 线程负责接收到数据，给 worker 线程分配数据，worker 线程取得一个任务后便可以开始工作，如果没有任务便阻塞住，节约 cpu 资源。 master 线程
c++ blocking queue 实现
digitaluser的博客
05-27 232
https://www.cnblogs.com/hatlonely/p/11945451.html
基于C++11实现的阻塞队列(BlockQueue)
weixin_50437588的博客
12-25 4427
当缓冲区满的时候，生产者会进入阻塞状态，当下次消费者开始消耗缓冲区的数据时，生产者才会被唤醒，开始往缓冲区中添加数据；当缓冲区空的时候，消费者也会进入阻塞状态，直到生产者往缓冲区中添加数据时才会被唤醒。因为要实现线程安全的函数，所以将pop函数的接口设计为需要放入一个自己的T item作为删除数据的拷贝。生产者不会在缓冲区满的时候继续向缓冲区放入数据，而消费者也不会在缓冲区空的时候，消耗数据。1、析构函数：清理队列中的所有成员，唤醒所有阻塞中的生产者、消费者线程。2、生产者线程应该调用的函数。
blockqueue阻塞队列的实现(C++)
最新发布
m0_73671329的博客
08-13 353
这个C++代码实现了一个阻塞队列（BlockQueue），它使用。来实现线程安全，类似生产者消费者的模型拓展。作为底层数据结构，并利用。
C++并发之阻塞队列(block,queue)
flysnow010的博客
06-25 916
最近研究了C++11的并发编程的线程/互斥/锁/条件变量，利用互斥/锁/条件变量实现一个支持多线程并发的阻塞队列，队列大小没有限制。阻塞队列是一个模板类，有两个模块参数，参数1是元素类型，参数2是容器类型，可以是std::deque和std::list,默认是std::deque。入队操作没有阻塞，出队操作如果队列为空则阻塞。
c++实现的阻塞队列
len_yue_mo_fu的博客
05-07 4705
阻塞队列(block_queue) 什么是阻塞队列： 在多线程编程时当有多个线程访问一个队列时如果队列为空，则获取队列中元素的方法就会阻塞，直到队列中有元素可以获取 解决的问题： 队列的线程安全问题 队列多线程取元素时的轮询判断问题 什么情况下需要阻塞队列： 在c++标准库STL中常用的队列容器都不是线程安全的，我们在多线程编程时总会有类似于生产者消费者这种模型，在这种模型下我们访问队列...
c++ 阻塞队列的实现
kelindame的专栏
03-10 1685
#include #include #include #include #include namespace WPAYRTL { template class BlockingQueue { public: BlockingQueue() {} ~BlockingQueue() {} void offer(std::shared_ptr &e) { { s
C++实现阻塞队列
weixin_42210846的博客
05-11 1052
#ifndef BLCOKING_QUEUE_H #define BLCOKING_QUEUE_H #include <memory> #include <list> #include <mutex> #include <condition_variable> template<typename T> class BlockingQueue { public: BlockingQueue() = default; BlockingQueue
阻塞队列（BlockingQueue）的实现和使用
闲来垂钓碧溪上的博客
03-29 722
阻塞队列是可以用于存放线程，因为阻塞队列可以对线程安全进行一种保护策略，当一个在队列中取一个线程时，如果阻塞队列中无线程，则会陷入等待状态，也就是阻塞，同样的，当队列空间满了之后，想要再加入线程，也会进入等待状态。”，高内聚是指代码的分布比较均匀，一个功能的代码就聚合在一起，使得程序员想修改一段代码时，可以轻易找到，也就是指关联代码分门别类的规制起来。可以正常使用，这里我们主要讲解了阻塞队列的实现以及使用，和阻塞队列与普通队列的区别，还有阻塞队列的线程安全问题。与队列相同，阻塞队列只是增加了。
[C++11] 线程安全的BlockingQueue
sai_j的博客
10-10 1062
参照muduo中的源码，使用C++11语法进行改写 #include &lt;mutex&gt; #include &lt;condition_variable&gt; #include &lt;deque&gt; template &lt;typename T&gt; class BlockingQueue { public: BlockingQueue() : mutex_(), c...
C++ queue的代码实现
Boyhou 的专栏
04-18 2025
队列是先进先出的结构。 首先贴出Queue类的结构： class Queue { public: Queue(int sz=10); bool EnQueue(double x); bool DeQueue(double & x); bool IsEmpty() const; bool IsFull() const; int GetSize() const; v
用C++简单实现的——BlockingQueue类(java)
huangjh2017的博客
05-12 890
最近，简单整理完Linux线程方面的知识点，突发奇想的想写个线程池来玩玩。经过多方的考虑，决定仿java的线程池来写。由于没有学过java，最后的结果可能差距很大，好像扯远了回到正题来。Java线程池中使用到了BlockingQueue类那就先来试着用C++来实现它吧！ 最终只实现了BlockingQueue中的ArrayBlockingQueue(基于数组的阻塞队列实现)和LinkedBlockingQueue(基于链表的阻塞队列)也只实现了BlockingQueue中4个核心的方法。好像对线程池来说够用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值