无锁队列一（简单实现）

最新推荐文章于 2024-05-06 10:36:11 发布
最新推荐文章于 2024-05-06 10:36:11 发布
阅读量175 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/splayx/article/details/84472543
版权

 

没多少行代码，先给出最终实现：

template<typename T>                                                            
class CAS {                                                                     
private:                                                                        
    T *pt_;                                                                     
    T old_val_;                                                                 
    T new_val_;                                                                 
public:                                                                         
    CAS(T *pt, T old_val, T new_val) {                                          
        pt_ = pt;                                                               
        old_val_ = old_val;                                                     
        new_val_ = new_val;                                                     
        while (!__sync_bool_compare_and_swap(pt, old_val, new_val));            
    }                                                                           
    ~CAS() {                                                                    
        if (new_val_ != __sync_val_compare_and_swap(pt_, new_val_, old_val_)) { 
            fprintf(stderr, "~CAS Error!\n");                                   
        }                                                                       
    }                                                                           
};

template<typename T>                                                            
class LockFreeQueue {                                                           
private:                                                                        
    T *queue_ptr_;                                                              
    int64_t mask_;                                                              
    int64_t __attribute((aligned (0x40))) head_;                                
    int64_t head_count_;                                                        
    int64_t head_pos_;                                                          
    int64_t __attribute((aligned (0x40))) tail_;                                
    int64_t tail_count_;                                                        
    int64_t tail_pos_;                                                          
                                                                                
    // head_count_ = |[head_pos_, tail_pos_)|                                   
    // tail_count_ = |(tail_pos_, head_pos_)|                                   
                                                                                
public:                                                                         
    LockFreeQueue(int64_t size) {                                               
        if (size <= 1 || size & (size - 1) != 0) {                              
            fprintf(stderr, "LockFreeQueue Error!");                            
            exit(1);                                                            
        }                                                                       
        mask_ = size - 1;                                                       
        queue_ptr_ = new T[size];                                               
                                                                                
        head_ = 0;                                                              
        tail_ = 0;                                                              
                                                                                
        head_pos_ = 0;                                                          
        tail_pos_ = size - 1;                                                   
                                                                                
        head_count_ = (tail_pos_ - head_pos_) & mask_;
        tail_count_ = (head_pos_ - tail_pos_ - 1) & mask_;                      
    }                                                                           
                                                                                
    // A full memory barrier around CAS should be guaranteed!                   
                                                                                
    // If queue is full return false,                                           
    // otherwise return true.                                                   
                                                                                
    //ease::Mutex en, de;                                                       
                                                                                
    bool Enqueue(T el) {                                                        
        //ease::MutexLock lock(&en);                                            
        CAS<int64_t> cas(&head_, 0, 1);                                         
                                                                                
        if (head_count_ == 0) {                                                 
            head_count_ = (tail_pos_ - head_pos_) & mask_;                      
            if (head_count_ == 0) return false;                                 
        }                                                                       
        head_count_--;                                                          
                                                                                
        queue_ptr_[head_pos_] = el;                                             
        __sync_synchronize();                                                   
        head_pos_ = (head_pos_ + 1) & mask_;                                    
                                                                                
        return true;                                                            
    }

    // If queue is emtpy return false,                                          
    // otherwise return true.                                                   
    bool Dequeue(T &el) {                                                       
        //ease::MutexLock lock(&de);                                            
        CAS<int64_t> cas(&tail_, 0x00, 0x01);                                   
                                                                                
        if (tail_count_ == 0) {                                                 
            tail_count_ = (head_pos_ - tail_pos_ - 1) & mask_;                  
            if (tail_count_ == 0) return false;                                 
        }                                                                       
        tail_count_--;                                                          
                                                                                
        el = queue_ptr_[(tail_pos_ + 1) & mask_];                               
        __sync_synchronize();                                                   
        tail_pos_ = (tail_pos_ + 1) & mask_;                                    
                                                                                
        return true;                                                            
    }                                                                           
};

这个实现的特点是两头分别是串行控制，但可以同步进行。

另外加入head_count_,tail_count_优化，可以减少两头信息同步带来的开销。

 

实现中几个注意的点：

1、

不大相关的变量组放在不同的cache line中，

这样可以避免它们所在的cache line作无谓的同步。

例如head_,tail_。

2、

一次调用中相关的，甚至是相互依赖的变量可以放在一个cache line中，

把数据集中起来更方便cpu处理，例如head_,head_pos_,head_count_。

3、

把常量性质的变量跟经常需要线程间同步的变量，放在不同的cache line中。

例如queue_ptr_， mask_，它们被读的时候，所在的cache line是不需要去同步的。

 

以上3点根据测试知是可以提升性能的。

 

4、

el = queue_ptr_[(tail_pos_ + 1) & mask_];                               
__sync_synchronize();                                                   
tail_pos_ = (tail_pos_ + 1) & mask_;

确保Enqueue线程看到数据出队操作是先于位置标志变化的，

不然标志变化先被Enqueue感知了，就可能导致原先的数据还没出队就被覆盖了。

5、

CAS的系统调用中会有一个full memory产生，这也是正确性的保证。

 

实例化一个无锁队列（LockFreeQueue<uint64_t> lfq(1 << 10);）

测试1000W个数据进出队列的所用的时间：

1 en-threads, 1 de-threads:
[test0] time consume: 1393ms
[test1] time consume: 1270ms
[test2] time consume: 1374ms
2 en-threads, 2 de-threads:
[test0] time consume: 1366ms
[test1] time consume: 1557ms
[test2] time consume: 1353ms
3 en-threads, 3 de-threads:
[test0] time consume: 3899ms
[test1] time consume: 4409ms
[test2] time consume: 4614ms
4 en-threads, 4 de-threads:
[test0] time consume: 8159ms
[test1] time consume: 8664ms
[test2] time consume: 11048ms
5 en-threads, 5 de-threads:
[test0] time consume: 11903ms
[test1] time consume: 11153ms
[test2] time consume: 12082ms

不难看出随着线程数的增加耗时也大概成线性增加。

另外把CAS换成MutexLock，测试结果是：

1 en-threads, 1 de-threads:                                                     
[test0] time consume: 2218ms                                                    
[test1] time consume: 2100ms                                                    
[test2] time consume: 2159ms                                                    
2 en-threads, 2 de-threads:                                                     
[test0] time consume: 2305ms                                                    
[test1] time consume: 2301ms                                                    
[test2] time consume: 2338ms                                                    
3 en-threads, 3 de-threads:                                                     
[test0] time consume: 2449ms                                                    
[test1] time consume: 2631ms                                                    
[test2] time consume: 2550ms                                                    
4 en-threads, 4 de-threads:                                                     
[test0] time consume: 2526ms                                                    
[test1] time consume: 2527ms                                                    
[test2] time consume: 2524ms                                                    
5 en-threads, 5 de-threads:                                                     
[test0] time consume: 2523ms                                                    
[test1] time consume: 2550ms                                                    
[test2] time consume: 2528ms

MutexLock随着线程数打增加，耗时增加没有CAS那么陡，相对比较平缓，

所以MutexLock开了很多线程仍然保持3000ms左右，当然开多了，耗时会越来越大。

 

可以得出的结论是当线程总数不大于cpu总核数的时候，无锁有一定的优势，

但是线程开多了，线程之间的cpu竞争将带来越来越多的开销。

 

这个实现比较简单，下来想一种两头都可以并行的做法。

C++ 无锁队列：原理与实现
xingyun86的专栏
02-20 601
无锁队列是一种在多线程编程中非常有用的数据结构，通过巧妙地使用原子操作和内存管理，避免了锁的使用，从而提升了性能。本文详细介绍了无锁队列的原理，并给出了完整的 C++ 实现代码及使用示例。希望通过本文的介绍，读者能够深入理解无锁队列的工作机制，并在实际项目中灵活运用这一技术。
C++无锁队列
weixin_43804370的博客
04-15 5002
利用原子操作基于c++语言实现的无锁队列
无锁队列英文论文(具有研究价值).zip
05-14
无锁队列英文论文(具有研究价值).zip
无锁(lock-free)队列的一个简单实现
jadedrip的专栏
03-06 3128
作为 无锁的 ( lock-free ) 线程安全算法 的一个习作吧。思想、算法十分简单。#ifdef WIN32 inline void sleep( uint32 mil ) { Sleep( mil ); } inline bool CAS(void* pDest, uint32 cmp, uint32 xchg){ return Interloc
python多进程没有锁队列范例
weixin_34364071的博客
03-21 469
假设有一些任务要完成。为了完成这项任务，将使用几个过程。所以，将保持两个队列。一个包含任务，另一个包含已完成任务的日志。 然后实例化流程来完成任务。请注意，python队列类已经同步。 这意味着，我们不需要使用锁类来阻塞多个进程来访问同一个队列对象。这就是为什么，在这种情况下不需要使用锁类。 下面是将任务添加到队列中的实现，然后创建进程并启动它们，然后使用join（）完成这些进程。最后，我们...
使用C++ 实现的无锁队列模板类
weixin_43868364的博客
03-12 345
使用C++ 模板实现的单生产者与单消费者的无锁队列 一个生产者与一个消费者的通信时，使用此无锁队列，无需任何锁即可保证线程安全 #include <vector> template<typename T> class ring { public: ring(int size):v(size+1),size(size+1) { }; ring(const ring& r) = delete; ring& operator = (const ring&amp
一种简单无锁队列的实现
蜗牛架构师
04-09 6775
Disruptor是内存无锁并发框架，基于一个环数组作为缓冲，详见Disruptor-1.0。 下面是自己设计的一个简易版，目前没有发现存在冲突或错误的测试用例。大家可以一起测试下。 package tianshui.lockfree.queue; import java.io.Serializable; import java.lang.reflect.Array; import
解析C++无锁队列的实现代码
09-05
总结起来，这个C++无锁队列的实现利用了`std::list`的数据结构和其提供的线程安全操作，实现了简单的单生产者单消费者无锁队列。然而，为了在多线程环境中获得更好的性能和扩展性，通常需要采用更复杂的无锁算法，...
c++11无锁队列的一种简单实现.pptx
03-08
例如，一个简单的无锁队列可能使用两个原子整数作为索引，分别表示队头和队尾。当一个线程尝试入队时，它会原子地更新队尾索引，而出队线程则会原子地更新队头索引。这种设计可以避免阻塞，提高并发性能。 在实际...
Linux内核中的无锁队列 - kfifo
12-29
在Linux内核中，`kfifo`（Kernel FIFO）是一种高效的无锁队列数据结构，它被设计为简单、优雅且性能卓越。`kfifo`的核心优势在于其在特定场景下能够避免锁的使用，从而提高系统的整体性能。在只有一个读线程和一个写...
C/C++编程：__sync_系列函数实现无锁原子类
OceanStar的博客
10-15 1808
函数声明 在gcc4.1.2版本之后，对X86和X86_64支持内置的原子操作。就会说，不需要引入第三方库(比如pthread)的锁保护，就可以对1、2、4、8字节的数值或者指针类型，进行原子的加/减/或/异或等操作。有了这套内置的原子操作，写程序就会方便很多。根据Gcc手册中，章节内容，将__sync_系列17个函数声明整理简化如下： type __sync_fetch_and_add (type *ptr, type value, ...)： 将value加到*ptr上，结果更新到*ptr，并返回操作
无锁队列Disruptor
LingHu66的博客
11-25 666
1.何为队列 听到队列相信大家对其并不陌生，在我们现实生活中队列随处可见，去超市结账，你会看见大家都会一排排的站得好好的，等待结账，为什么要站得一排排的，你想象一下大家都没有素质，一窝蜂的上去结账，不仅让这个超市崩溃，还会容易造成各种踩踏事件，当然这些事其实在我们现实中也是会经常发生。 当然在计算机世界中，队列是属于一种数据结构，队列采用的FIFO(first in firstout)，新元素（等待进入队列的元素）总是被插入到尾部，而读取的时候总是从头部开始读取。在计算中队列一般用来做排队(如线程池的等待排
无锁队列实现：Lock free queue 大比拼题目 （tp://coderpk.com/）
05-19 303
04 09/12 Lock free queue 大比拼 10:43 pm by livexmm. Filed under: Code Play,Life 有人在微博上发起了挑战，貌似很碉堡的样子，特别还创建了一个网站： http://coderpk.com/ 一向对解决此类问题有所兴趣于是尝试了我的做法： 首先我想到的问题是我去设计一个纯粹的多读多写无锁队列
环形无锁队列的简易实现
__xzwdev__
03-20 1101
/* * RingBuf.h * * Created on: Feb 7, 2015 6:06:10 PM * Author: xuzewen */ #ifndef RINGBUF_H_ #define RINGBUF_H_ #include /** * * 多/单线程生产, 只能单线程消费, 尺寸固定为0x10000. * * */ class RingBu
C++ 实现无锁队列——单读单写、多读多写
一枚菜鸡
05-06 1540
之前学习了 C++ 中原子变量的内存顺序，现在我们来看看原子变量和内存顺序的应用 – 无锁队列。本文介绍单写单读和多写多读的无锁队列的简单实现，从中可以看到无锁数据结构设计的一些基本思路。
内纯屏障---__sync_synchronize()
Hunterhong的专栏
07-21 7958
内存屏障是一个程序员要面对的涉及CPU方面知识的一个问题。在多核多线程的情况下，如果你不知道这个CPU乱序执行这个问题的话，将会是一场噩梦，无论怎么进行代码走读也不可能发现的bug。不过只要加上一个__sync_synchronize()  问题就迎刃而解。 这是我的第一篇blog，明天要去面试了，先写引子，以后有空再写。
[c++]无锁队列
I have a adream
10-01 793
/* * lock free queue, thread safe * this paper "A practical nonblocking queue algorithm using compare-and-swap" provide the main idea * queue.hpp * enqueue into the tail * dequeue from head */ #
多线程编程之无锁队列
anwu0979的博客
12-08 200
关于无锁队列的概念与实现，可以参考博文《无锁队列的实现》，主要涉及到的知识点包括CAS原子操作、无锁队列的链表实现、无锁队列的数组实现以及ABA问题。 　　下面借鉴了《多线程的那点儿事（之无锁队列）》的代码，说明两个线程（一个添加一个读取数据）之间的无锁队列，可以不借助线程互斥方法就能够达到并行效果。代码如下： #define MAX_NUMBER 1000L #define ...
多写多读-线程安全队列4
papiping的专栏
12-13 350
//放入数据的过程 template bool TMultiRWQueue::myPut(Element& data) {  if (!m_lockPut.Lock())  {   return false;  }    //拷贝元素数据到空闲节点  *m_Put = data;  //空闲节点指向下一个位置  m_Put++;  if (m_Put >= m_Tail
使用stl实现无锁队列
最新发布
03-08
<think>嗯，用户让我介绍一下如何使用STL实现无锁队列。首先，我需要明确几个关键点。无锁队列是一种并发数据结构，它允许多线程同时访问而无需使用互斥锁。STL是C++的标准模板库，但标准库中的容器通常不是线程安全的，更不用说无锁了。所以用户的问题可能有些矛盾，因为直接使用STL容器实现无锁队列可能不可行，但也许需要结合STL的一些组件和原子操作来实现。 首先，我得回忆一下无锁编程的基本概念。无锁结构通常依赖于原子操作和内存顺序来确保线程安全。STL中提供了<atomic>头文件，里面有std::atomic模板，可以用来实现原子变量。但STL的容器如queue或list本身不是设计为无锁的，所以可能需要自己用原子操作和节点结构来构建。 用户可能想了解如何利用STL提供的原子操作和一些数据结构，比如智能指针或者节点结构，来手动实现一个无锁队列。比如，可以使用std::atomic<Node*>来表示头尾指针，然后通过CAS（比较并交换）操作来更新指针，保证线程安全。 接下来，我需要考虑无锁队列的常见实现方式，比如Michael-Scott算法，这是一种经典的基于链表的无锁队列。算法中使用两个指针，head和tail，入队和出队操作通过原子操作来更新这些指针。这时候，可能需要定义一个节点结构体，包含数据和下一个节点的原子指针。 然后，STL中的std::atomic是否足够支持这些操作？比如，对于指针的原子操作，std::atomic<Node*>确实支持load、store、compare_exchange_weak等操作，这些是实现无锁队列所必需的。 另外，内存管理的问题也需要考虑。当节点被弹出队列后，可能有其他线程还在访问它，因此不能立即释放内存。这时候可能需要使用风险指针（hazard pointers）或者引用计数等技术来安全地回收内存。STL中的智能指针如std::shared_ptr可能在这里派上用场，但需要检查其原子操作的支持情况。不过，std::shared_ptr的原子操作可能会有性能问题，或者需要特定的内存顺序。 还需要考虑ABA问题，即在CAS操作中，指针的值可能被其他线程释放并重新分配，导致虽然地址相同但内容不同。这可以通过使用带标记的指针或者使用双重宽度的CAS指令来解决，但C++的std::atomic是否支持这些需要确认。例如，在某些平台上，可以使用std::atomic<T*>结合位操作来处理标记，但可能不够便携。 然后，可能需要给出一个简单的示例代码，展示如何用std::atomic和节点结构实现无锁队列的基本结构。但需要注意，完整的无锁队列实现非常复杂，涉及到正确的内存顺序和ABA问题的处理，用户可能需要了解这些限制。 总结一下，步骤可能包括： 1. 定义节点结构，包含数据和原子指针。 2. 使用std::atomic<Node*>表示头尾指针。 3. 实现入队和出队操作，使用CAS操作更新指针。 4. 处理内存回收问题，可能需要结合STL的智能指针或其他机制。 5. 处理ABA问题和内存顺序，确保线程安全。 用户可能对无锁编程不太熟悉，因此需要解释这些概念，并指出直接使用STL容器无法实现无锁队列，必须自己构建结构，结合原子操作。此外，需要提醒用户无锁编程的复杂性和潜在陷阱，比如正确性和性能问题。</think>以下是使用C++ STL结合原子操作实现无锁队列的简要指南： ```cpp #include <atomic> #include <memory> template<typename T> class LockFreeQueue { private: struct Node { std::shared_ptr<T> data; // 使用智能指针管理数据 std::atomic<Node*> next; Node(T value) : data(std::make_shared<T>(std::move(value))), next(nullptr) {} }; std::atomic<Node*> head; std::atomic<Node*> tail; public: LockFreeQueue() { Node* dummy = new Node(T{}); // 哨兵节点 head.store(dummy); tail.store(dummy); } void enqueue(T value) { Node* newNode = new Node(std::move(value)); while(true) { Node* oldTail = tail.load(); Node* next = oldTail->next.load(); // 确保tail仍指向原节点 if(oldTail == tail.load()) { if(next == nullptr) { // 尝试原子性更新next指针 if(oldTail->next.compare_exchange_weak(next, newNode)) { // 推进tail指针 tail.compare_exchange_weak(oldTail, newNode); return; } } else { // 帮助其他线程完成尾指针推进 tail.compare_exchange_weak(oldTail, next); } } } } bool dequeue(T& result) { while(true) { Node* oldHead = head.load(); Node* oldTail = tail.load(); Node* next = oldHead->next.load(); if(oldHead == head.load()) { if(oldHead == oldTail) { if(next == nullptr) return false; // 队列为空 // 推进tail指针 tail.compare_exchange_weak(oldTail, next); } else { // 尝试取出数据 result = *next->data; // 推进head指针 if(head.compare_exchange_weak(oldHead, next)) { delete oldHead; // 内存回收存在风险 return true; } } } } } }; ``` 关键实现要点： 1. 基于链表的Michael-Scott算法 - 使用哨兵节点简化边界条件处理 - 包含head和tail两个原子指针 - 入队/出队操作采用CAS原子指令 2. 内存管理问题 - 使用std::shared_ptr自动管理数据内存 - 节点删除存在ABA问题（示例代码未完全解决） - 生产环境建议使用内存回收方案（Hazard Pointer/EBR） 3. 原子操作选择 - compare_exchange_weak实现无锁保证 - memory_order_relaxed可优化性能（需谨慎） - 保证可见性的内存屏障设置 实际注意事项： 1. ABA问题解决方案： - 使用带标签的指针（指针地址+版本号） - 依赖平台特定的双字CAS指令（如CMPXCHG16B） 2. 完整实现应包含： - 迭代器支持 - 容量限制 - 异常安全保证 - 动态内存回收 3. 性能优化方向： - 批量操作支持 - 缓存行对齐（alignas(64)） - 避免false sharing 替代方案参考： 1. 使用boost::lockfree::queue 2. 基于环形缓冲区的实现 3. 结合TSX事务内存（Intel® TSX） 建议优先使用成熟的无锁库（如Folly的AtomicHashMap），自行实现需进行严格的多线程压力测试。无锁数据结构虽然避免了锁竞争，但在高并发场景下可能产生更复杂的缓存一致性开销。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值