并发高性能C++ 双向队列，数据越多速度越快

优秀会上瘾

已于 2024-02-17 14:17:41 修改

阅读量1.5k

点赞数 53

分类专栏：实战项目C++ 文章标签： c++ 开发语言

于 2024-02-16 09:00:00 首次发布

本文链接：https://blog.csdn.net/u010872708/article/details/136122102

版权

实战项目C++ 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

本文介绍了如何使用C++实现一个高性能的队列类PackageCache，模仿DX3D12游戏绘制队列的设计，包括添加数据、获取数据以及线程安全操作。代码示例展示了如何在主函数中使用该队列进行数据传输。

摘要由CSDN通过智能技术生成

C++ 11 实现高性能队列，参考DX 3D 12 游戏绘制队列部分设计方式。

测试代码可以从文章中下载：

直接干货：

using test_buffer = std::basic_string<unsigned char, std::char_traits<unsigned char>, std::allocator<unsigned char>>;

也可直接使用std::string

以上 test_buffer 代码定义只是希望给新手提供更多的字符串操作方式用例。

int main()
{
	PackageCache<test_buffer>	m_cacheDatas;

	std::future<void>	testThread;

	testThread = std::async(std::launch::async, [&] 
	{
		for (int i = 0; i < 13000; i++)
		{
			char buff[8] = { 0 };
			sprintf_s(buff, "%d", i);
			m_cacheDatas.addData(test_buffer(buff));

			if (i > 12000)
				Sleep(1);
		}

		m_cacheDatas.addData(test_buffer("-1"));
	});

	Sleep(100);

	test_buffer temp;

	while (true)
	{
		if (m_cacheDatas.getPackage(temp))
		{
			printf("recv: %s\n", temp.c_str());

			if (temp == "-1")
				break;
		}
		else
		{
			Sleep(10);
		}
	}

	testThread.wait();

	return 0;
}

模版类


#pragma once

#include <string>
#include <queue>
#include <mutex>

template<class T>
class PackageCache final
{
public:

	void addData(const T& data)
	{
		m_mutex.lock();
		m_queueBackCache.emplace(std::move(data));
		m_mutex.unlock();
	}

	inline int getLen() { return (int)m_queueBackCache.size(); }

	bool getPackage(T& ret)
	{
		if (m_queueFrontCache.size() <= 0)
			moveData(m_queueFrontCache);

		bool bRet = false;

		if (m_queueFrontCache.size() > 0)
		{
			bRet = true;
			ret = std::move(m_queueFrontCache.front());
			m_queueFrontCache.pop();
		}

		return bRet;
	}

	template<class T1>
	void clear()
	{
		std::queue<T1> temp1;
		std::queue<T1> temp2;
		m_mutex.lock();
		m_queueBackCache = std::move(temp1);
		m_queueFrontCache = std::move(temp1);
		m_mutex.unlock();
	}

protected:
	bool moveData(std::queue<T>& ret)
	{
		bool bRet = false;

		m_mutex.lock();
		if (m_queueBackCache.size() > 0)
		{
			ret = std::move(m_queueBackCache);
			bRet = true;
		}
		m_mutex.unlock();

		return bRet;
	}

protected:
	std::queue<T>	    m_queueBackCache;
	std::queue<T>		m_queueFrontCache;
	std::mutex			m_mutex;
};