利用std::atomic实现无锁队列

原创 已于 2024-05-15 19:06:25 修改 · 1.5k 阅读 · 30 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言

于 2024-05-15 18:13:14 首次发布

队列基础，一对一无锁

队列就是一个先进先出的数据结构，一般使用链表实现，如下图：

数据从Head进入链表，从Tail出链表。我们会发现，只要链表一直不是空的，那么Head指针和Tail指针是完全无关的，也就是读写之间不加锁的线程安全比较容易实现，我们只要保证链表从初始化开始Head和Tail就无关即可，那么一对一的生产者和消费者无锁队列就可以十分简单地实现，显然Tail或者Head直接指向的内存我们不用来存储数据，是最合理的。

上述两种方式都可以，我们采用第一种展开讲述。在队列创建时，我们让Head和Tail共同指向一个不存储数据的内存，从此这两个指针就可以毫不相干了，后续生产消费中，Tail总是预留一个不存储数据的内存节点，而Head则只需要完成自己的指向操作。以下是相关代码：

template <typename T>
class T1V1Queue : NonCopyable {
 public:
  using ElementType = T;
  T1V1Queue() : mSize(0) { mHead = mTail = new TNode; }
  ~T1V1Queue() {
    while (mTail != nullptr) {
      T
最低0.47元/天 解锁文章
qiguodie
关注
无锁链表的实现（C++编程）
Book_Sea的博客
09-03 310
然而，需要注意的是，无锁编程是一项复杂的任务，并且容易出错。在实际应用中，需要仔细考虑并发访问的各种情况，以确保数据的一致性和正确性。无锁链表的实现依赖于原子操作，C++中的std::atomic类提供了一组原子操作函数。如果头节点不匹配，则遍历链表查找要删除的节点，并更新前驱节点的next指针。在示例程序中，我们创建两个线程，一个线程用于插入节点，另一个线程用于删除节点。在删除操作中，我们使用delete操作来释放被删除节点的内存。链表类包含一个指向头节点的指针，并提供插入和删除节点的操作。
C++ 线程安全队列：手把手实现高效的无锁或有锁队列
weixin_41455464的博客
07-14 407
今天咱们一起学习了线程安全队列的两种实现方式：有锁队列和无锁队列。各位观众，各位听众，欢迎来到今天的“C++线程安全队列：手把手实现高效的无锁或有锁队列”讲座。MPSC 无锁队列的实现比 SPSC 队列复杂得多，需要解决多个生产者和消费者之间的竞争问题。这段代码展示了如何使用有锁队列和 SPSC 无锁队列，并通过简单的测试来比较它们的性能。由于篇幅限制，这里只给出 MPSC 队列的基本思路，不提供完整的代码实现。无锁队列的实现通常基于循环队列，并使用原子操作来管理队列的头尾指针。模板类，用于实现原子操作。
atomic_queue：C ++无锁队列
01-28
atomic_queue 基于带有循环缓冲区的C ++ 14多生产者多消费者无锁队列。 这些队列遵循的主要设计原理是极简主义：原子操作的最基本要求，固定大小的缓冲区，值语义。 这些品质也有局限性： 最大队列大小必须在编译时或构造时设置。 循环缓冲区以固定缓冲区大小为代价，回避了基于链表的队列中固有的内存回收问题。 有关更多详细信息，请参见。 固定的缓冲区大小可能没有太大的限制，因为一旦队列变得大于最大预期大小，这表明存在元素处理速度不够快的问题，并且如果队列持续增长，它最终可能会消耗所有可用的内存。可能会影响整个系统，而不仅是有问题的过程。 唯一明显的不便之处是，必须对预期或可接受的最大队列大小进行预先的信封后计算。 没有操作系统阻止推送/弹出功能。 此队列是为超低延迟方案设计的，使用OS阻塞原语将牺牲一键弹出延迟。 为了获得尽可能低的延迟，人们无法承受OS内核中的阻塞，因为阻塞线程的唤醒延迟约为1-3微秒，而此队列的往返时间可以低至150纳秒。 超低延迟应用程序仅需此而已。 极简主义带来了回报，请参阅。 可用的容器有： AtomicQueue原子元素的固定大小的环形缓
c++11 无锁队列
qq_35728402的博客
08-08 4950
/************************************************************************* &gt; File Name: lockfreequeue.cpp &gt; Author: &gt; Mail: &gt; Created Time: Wed 08 Aug 2018 11:38:08 AM CST ********...
Atomic实现多线程下，无锁的进行原子操作
琦彦
06-20 7443
AtomicInteger这个类的存在是为了满足在高并发的情况下,原生的整形数值自增线程不安全的问题。
c++11新特性之atomic
weixin_30520015的博客
09-27 437
std::atomic_flag 　　std::atomic_flag是一个原子的布尔类型，可支持两种原子操作： test_and_set, 如果atomic_flag对象被设置，则返回true; 如果atomic_flag对象未被设置，则设置之，返回false clear. 清楚atomic_flag对象 　　std::atomic_flag可用于多线程之间的同步操作，类...
c++ 无锁队列的简单实现
北辰的博客
07-15 947
一个关于无锁队列的多线程读写代码示例。在这里，我提供一个简单的示例来说明这个问题。在使用无锁队列时，需要注意以下几点：使用原子操作来实现对队列的读写操作，以避免多线程同时访问同一数据导致的竞争条件问题。当队列为空或已满时，需要使用特殊的标记来表示队列的状态。使用链表来实现的无锁队列这段代码实现了一个无锁队列，其中enqueue()函数用于向队列中添加元素，dequeue()函数用于从队列中取出元素。
多线程性能测试：ConcurrentQueue（无锁队列）、std::atomic_flag 和 std::mutex
Where there is life, there is hope.
07-01 2195
本测试比较了无锁队列和std::mutex在多线程环境下的表现。结论对于使用 std::mutex 的 std::list 或 std::deque，如果 Item 结构体较小，推荐使用 std::atomic_flag 代替 std::mutex。如果 Item 结构体较大，继续使用 std::mutex。新的业务代码可以酌情使用无锁队列 ConcurrentQueue。
【C++编程高手技巧】：std::atomic打造线程安全无锁队列的方法
[【C++编程高手技巧】：std::atomic打造线程安全无锁队列的方法](https://img-blog.csdnimg.cn/1508e1234f984fbca8c6220e8f4bd37b.png) # 1. C++多线程编程基础与原子操作概念 ## 1.1 多线程编程的重要性 在现代...
Modern C++ std::atomic简介
一些C++相关的技术笔记或者教程.
12-28 1274
探讨 std::atomic 的特性、使用方法及其在实际开发中的应用场景
简单易用的无锁队列atomic_queue
xulanshuai01的博客
06-03 502
atomic_queue是一个基于C++14原子操作实现的高性能无锁队列，专为多线程数据交换设计。其特点包括：完全无锁设计（基于原子操作）、性能比传统锁队列快5-10倍、支持多生产者多消费者模式。作为头文件库，只需简单包含即可使用，提供阻塞和非阻塞两种模式。示例代码展示了生产者-消费者模型的实现，通过原子操作避免了锁竞争，显著提升高并发场景下的性能表现。该库轻量高效，是替代传统锁队列的理想选择。
c语言 无锁编程,C语言 使用boost :: atomic的无锁队列 – 我这样做了吗？
weixin_33685869的博客
05-19 413
精简版：我试图从here替换无锁,单生成器,单消费者队列实现中使用的C 11中的std :: atomic.如何用boost::atomic替换它？长版：我正试图通过工作线程从我们的应用程序中获得更好的性能.每个线程都有自己的任务队列.我们必须在出列/排队每个任务之前使用锁同步.然后我找到了Herb Sutter关于无锁队列的文章.这似乎是一个理想的替代品.但代码使用了C 11中的std :: a...
atomic无界队列
zgrztzy的博客
02-08 244
#include <stdint.h> //#include <unistd.h> #include <atomic> #include <memory> template <typename T> class UnboundedQueue { public: UnboundedQueue() { auto node = ...
[C++]boost提供的几种lock-free方案以及std::atomic实现无锁队列
玄冬Wong
04-18 3796
boost方案 boost提供了三种无锁方案 boost::lockfree::queue： 支持多个生产者和多个消费者线程的无锁队列。 boost::lockfree::stack： 支持多个生产者和多个消费者线程的无锁栈。 boost::lockfree::spsc_queue： 仅支持单个生产者和单个消费者线程的无锁队列。相比boost::lockfree::queue，其...
C++ 无锁队列
小小的进步
07-03 1804
atomic类型的操作是原子操作，是不可分割的，不能被中断的操作。 程序代码中的一条简单赋值语句会被翻译为多条汇编指令，那么多个线程同时对某一存储单元进行修改，就有可能出现脏数据，原子操作可以避免脏数据的出现。 2. 多线程读写 三、总结 无锁队列依靠原子和CAS操作，对队列的读写索引进行判断来入队和出队，它没有使用互斥量mutex来进行加锁，从性能上具有明显的优势，但同时编程的复杂性增加了很多，在编码时也要对内存序有简单的了解。...
探索超低延迟的无锁队列：atomic_queue
gitblog_00031的博客
05-14 779
在多线程和并发编程中，高效的队列管理是关键性能瓶颈之一。今天我们要介绍的是一个名为`atomic_queue`的开源库，它为C++14带来了基于原子操作的多生产者多消费者（MPMC）无锁队列，旨在最小化线程间元素推送与消费的延迟。 ## 1、项目介绍 `atomic_queue`是一个高度优化的固定大小环形缓冲区实现，利用了`std::atomic`来提供无锁的数据结构。它支持Linux平台上...
无锁队列的实现（基于atomic和CAS）
最新发布
记录C++学习途中一些重要知识点和见解。
08-18 681
之前提到了基于有锁、无锁和IOCP的线程安全队列的实现方式，这篇文章详细解释一下无锁队列的实现。
[数据结构]——无锁队列
木牛的博客
03-21 2609
(152条消息) [数据结构]——无锁队列_lucky52529的博客-优快云博客_无锁队列无锁队列 写这篇博客前想声名以下几点。第一，这篇文章重点内容是关于无锁队列如何实现，并不会深入讲解底层的CAS机制。原因就是第二条，不知道在看博客的你是否在搜索框中输入过"无锁队列"关键字，你点开居然会惊讶的发现每一篇居然都是那么的相似，一直不理解写博客A抄B，B抄C只是为了骗访客吗？ 这篇被抄来抄去的博客就是酷壳陈皓老师的原创，老师的博客中深入讲解了无锁队列的原理。只是缺少最后一份代码的实现，既然有大牛级别的
C++无锁队列
qq_42752426的博客
10-18 1717
无锁队列（Lock-Free Queue）是一种在多线程环境中使用的数据结构，它不需要使用互斥锁（mutex）来保护共享资源，从而避免了锁的开销和死锁问题。无锁队列通常使用原子操作（如 compare_exchange_strong）来实现线程安全的操作。
std::atomic 是如何实现互斥的
07-30
### 互斥机制的实现基础 在多线程编程中，互斥机制用于确保多个线程不会同时访问共享资源，从而避免数据竞争和不一致的状态。`std::atomic` 是 C++11 引入的标准库工具，它提供了一种轻量级的、基于硬件支持的原子操作机制，可以用来实现线程间的同步和互斥访问共享数据。 `std::atomic` 的核心在于它对特定类型的操作提供了原子性保证。这意味着，即使在多个线程并发执行的情况下，这些操作也不会被中断或部分执行，从而避免了中间状态的暴露。例如： ```cpp std::atomic<bool> flag(false); // 线程 A flag.store(true, std::memory_order_seq_cst); // 线程 B if (flag.load(std::memory_order_seq_cst)) { // 安全地访问共享资源 } ``` 上述代码中，`store` 和 `load` 操作是原子的，并且通过 `std::memory_order_seq_cst`（顺序一致性）内存序保证了操作的可见性和顺序性。这种机制可以用来构建简单的互斥锁，如自旋锁（spinlock）或信号量。 ### 内存序与同步语义 `std::atomic` 的互斥实现不仅依赖于原子性，还依赖于内存序（memory order）的约束。内存序决定了操作对其他线程的可见顺序。常见的内存序包括： - `std::memory_order_relaxed`：仅保证操作的原子性，不提供任何同步语义。 - `std::memory_order_acquire` 和 `std::memory_order_release`：用于构建同步屏障，确保操作前后的内存访问顺序。 - `std::memory_order_seq_cst`：最强的内存序，确保所有线程看到的操作顺序一致。 例如，在实现一个简单的互斥锁时，可以使用 `std::atomic_flag` 或 `std::atomic<bool>` 来表示锁的状态，并通过 `test_and_set` 或 `exchange` 操作实现原子的加锁和解锁： ```cpp class SpinLock { public: void lock() { while (flag.test_and_set(std::memory_order_acquire)) { // 等待锁释放 } } void unlock() { flag.clear(std::memory_order_release); } private: std::atomic_flag flag = ATOMIC_FLAG_INIT; }; ``` 在此示例中，`test_and_set` 是一个原子操作，它将标志设置为 `true` 并返回其先前的值。如果标志已经被设置，则线程会持续等待，直到其他线程调用 `unlock` 并清除标志。 ### 原子操作与内存屏障 除了提供原子性，`std::atomic` 还可以通过显式的内存屏障（fence）来控制内存访问顺序。例如，`std::atomic_thread_fence` 可以插入一个屏障，防止编译器和处理器对内存操作进行重排序[^1]。这在实现更复杂的同步结构（如无锁队列）时非常有用。 ```cpp std::atomic<int> x(0), y(0); int r1, r2; void thread1() { x.store(1, std::memory_order_relaxed); std::atomic_thread_fence(std::memory_order_release); r1 = y.load(std::memory_order_relaxed); } void thread2() { y.store(1, std::memory_order_relaxed); std::atomic_thread_fence(std::memory_order_release); r2 = x.load(std::memory_order_relaxed); } ``` 在上述代码中，`std::atomic_thread_fence` 用于确保 `store` 操作在 `load` 操作之前执行，从而避免因重排序导致的错误结果。 ### 总结 `std::atomic` 提供了一种高效、灵活的方式来实现线程间的互斥和同步。它通过原子操作和内存序控制，确保对共享数据的访问是线程安全的。相比于传统的互斥锁（如 `std::mutex`），`std::atomic` 具有更低的开销，适用于对性能要求较高的场景，但也需要开发者对内存模型有更深入的理解。 ###
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值