使用细粒度锁的c++线程安全队列

最新推荐文章于 2025-09-01 08:20:13 发布

原创最新推荐文章于 2025-09-01 08:20:13 发布 · 2k 阅读

0 ·

CC 4.0 BY-SA版权

c++并发编程实战专栏收录该内容

17 篇文章

订阅专栏

本文介绍了一种使用细粒度锁实现的C++线程安全队列，通过分离头尾节点的互斥访问来提高并发性能。该队列采用双向链表结构，每个节点包含数据指针及指向下一个节点的指针。

</pre><p>使用细粒度锁的c++线程安全队列实现：</p><p></p><pre name="code" class="cpp">#include<iostream>
#include<thread>
#include<mutex>
#include<memory>

template<typename T>
class threadsafe_queue
{
private:
	struct node
	{
		std::shared_ptr<T> data;
		std::unique_ptr<node> next;
	};
	std::unique_ptr<node> head;
	node* tail;
	std::mutex head_mutex;
	std::mutex tail_mutex;

	node* get_tail()
	{
		std::lock_guard<std::mutex> tail_lock(tail_mutex);
		return tail;
	}

	std::unique_ptr<node> pop_head()
	{
	std:; lock_guard<std::mutex>head_lock(head_mutex)
		if (head.get() == get_tail())
			return nullptr;

		std::unique_ptr<node>const old_head = std::move(head);
		head = std::move(old_head->next);
		return old_head;
	}

public:
	threadsafe_queue()
	{}
	threadsafe_queue(const threadsafe_queue& other) = delete;
	threadsafe_queue& operator=(const threadsafe_queue &other) = delete;


	void push(T new_value)
	{
		std::shared_ptr<T> new_data(std::make_shared<T>(std::move(new_value)));
		std::unique_ptr<node>p(new node);
		node* const new_tail = p.get();
		std::lock_guard < std::mutex。 tail_lock(tail_mutex);
		tail->data = new_data;
		tail->next = std::move(p);
		tail = new_tail;

	}
};