C++无锁队列

最新推荐文章于 2025-04-09 15:41:40 发布
最新推荐文章于 2025-04-09 15:41:40 发布
阅读量1.2k 收藏 10
点赞数 15
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/chenmi123321/article/details/146142288
版权

1. 无锁队列定义

无锁队列（Lock-Free Queue）是一种在多线程环境下实现的队列数据结构，它不依赖传统的锁机制（如互斥锁 std::mutex）来保证线程安全。而是通过原子操作（如 std::atomic 提供的操作）和内存屏障来确保多个线程可以同时对队列进行入队（enqueue）和出队（dequeue）操作，且不会出现数据竞争和不一致的问题。

2. 功能

无锁队列主要具备以下两个核心功能：

2.1 入队操作（Enqueue）

入队操作是将一个新元素添加到队列的尾部。在无锁队列中，入队操作需要保证在多线程环境下，新元素能够正确地插入到队列尾部，且不会破坏队列的结构。通常，入队操作会使用原子比较并交换（Compare-And-Swap, CAS）操作来更新队列的尾指针。

2.2 出队操作（Dequeue）

出队操作是从队列的头部移除一个元素并返回。在无锁队列中，出队操作需要确保在多线程环境下，能够正确地移除队列头部元素，同时避免出现多个线程同时移除同一个元素的情况。同样，出队操作也会使用 CAS 操作来更新队列的头指针。

3. 无锁队列作用

无锁队列在多线程编程中具有重要的作用，主要体现在以下几个方面：

3.1 提高并发性能

传统的锁机制（如互斥锁）在多线程环境下会引入较大的开销，因为线程在访问共享资源时需要先获取锁，这会导致线程的阻塞和上下文切换。而无锁队列通过原子操作避免了锁的使用，减少了线程的阻塞和上下文切换，从而提高了并发性能。多个线程可以同时进行入队和出队操作，充分利用多核处理器的并行计算能力。

3.2. 避免死锁问题

死锁是多线程编程中常见的问题，当多个线程相互等待对方释放锁时，就会发生死锁。无锁队列不使用锁机制，因此从根本上避免了死锁的发生，提高了系统的稳定性和可靠性。

3.3 实现异步通信和任务调度

无锁队列常用于实现异步通信和任务调度系统。例如，在生产者 - 消费者模型中，生产者线程可以将任务添加到无锁队列中，消费者线程可以从队列中取出任务进行处理。由于无锁队列的高并发性能，能够高效地处理大量的任务，提高系统的吞吐量。

3.4. 实时系统和高性能计算

在实时系统和高性能计算领域，对系统的响应时间和性能要求非常高。无锁队列的低延迟和高并发特性使其成为这些领域的理想选择。例如，在游戏开发、金融交易系统等场景中，无锁队列可以用于实现高效的消息传递和任务调度。

4. 参考代码

下面是C++ 实现的无锁队列，采用原子操作来保证线程安全，避免使用传统的锁机制。这个无锁队列使用链表作为底层数据结构，实现了入队（enqueue）和出队（dequeue）操作。

#include <iostream>
#include <atomic>
#include <thread>
#include <vector>

// 定义队列节点结构体
template <typename T>
struct Node {
    T data;
    std::atomic<Node<T>*> next;
    Node(const T& value) : data(value), next(nullptr) {}
};

// 定义无锁队列类
template <typename T>
class LockFreeQueue {
private:
    std::atomic<Node<T>*> head;
    std::atomic<Node<T>*> tail;

public:
    LockFreeQueue() {
        Node<T>* dummy = new Node<T>(T());
        head.store(dummy);
        tail.store(dummy);
    }

    ~LockFreeQueue() {
        while (dequeue());
        delete head.load();
    }

    // 入队操作
    void enqueue(const T& value) {
        Node<T>* newNode = new Node<T>(value);
        Node<T>* oldTail = tail.load(std::memory_order_relaxed);
        while (!tail.compare_exchange_weak(oldTail, newNode, std::memory_order_release, std::memory_order_relaxed)) {}
        oldTail->next.store(newNode, std::memory_order_release);
    }

    // 出队操作
    bool dequeue(T* result = nullptr) {
        Node<T>* oldHead = head.load(std::memory_order_relaxed);
        Node<T>* next = oldHead->next.load(std::memory_order_acquire);
        if (next == nullptr) {
            return false;
        }
        if (head.compare_exchange_strong(oldHead, next, std::memory_order_release, std::memory_order_relaxed)) {
            if (result) {
                *result = next->data;
            }
            delete oldHead;
            return true;
        }
        return false;
    }
};

// 测试代码
void testLockFreeQueue() {
    LockFreeQueue<int> queue;

    // 入队线程函数
    auto enqueueTask = [&queue]() {
        for (int i = 0; i < 100; ++i) {
            queue.enqueue(i);
        }
    };

    // 出队线程函数
    auto dequeueTask = [&queue]() {
        int value;
        for (int i = 0; i < 20; ++i) {
            while (!queue.dequeue(&value)) {}
            // 可以在这里打印出队的值进行验证
            std::cout << "Dequeued: " << value << std::endl;
        }
    };

    // 创建入队和出队线程
    std::vector<std::thread> threads;
    for (int i = 0; i < 4; ++i) {
        threads.emplace_back(enqueueTask);
        threads.emplace_back(dequeueTask);
    }

    // 等待所有线程完成
    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "Test completed." << std::endl;
}

int main() {
    testLockFreeQueue();
    return 0;
}

5. 参考代码输出结果

Dequeued: 0
Dequeued: 1
Dequeued: 2
Dequeued: 3
Dequeued: 4
Dequeued: 5
Dequeued: 6
Dequeued: 7
Dequeued: 9
Dequeued: Dequeued: 10
Dequeued: 11
Dequeued: 12
Dequeued: 13
Dequeued: 14
Dequeued: 0
Dequeued: 1
Dequeued: 2
Dequeued: 3
Dequeued: 4
Dequeued: 5
Dequeued: 6
Dequeued: 7
Dequeued: 8
Dequeued: 9
Dequeued: 10
Dequeued: 11
Dequeued: 12
Dequeued: 13
Dequeued: 14
Dequeued: 0
Dequeued: 1
Dequeued: 2
Dequeued: 3
Dequeued: 4
Dequeued: 5
Dequeued: 6
Dequeued: 7
Dequeued: 8
Dequeued: 9
Dequeued: 10
Dequeued: 11
Dequeued: 12
Dequeued: 14
Dequeued: 13
8
Dequeued: Dequeued: 01
Dequeued: 4
Dequeued: 5
Dequeued: 6
Dequeued: 7
Dequeued: 8
Dequeued: 9
Dequeued: 10
Dequeued: 11
Dequeued: 12
Dequeued: 13
Dequeued: 14
Dequeued: 3

Dequeued: 2

6. 代码解释

6.1 入队操作 enqueue：

1）创建一个新节点 newNode。
2）使用 tail.load(std::memory_order_relaxed) 获取当前的尾指针 oldTail。
3）使用 compare_exchange_weak 原子操作尝试将尾指针更新为 newNode。如果更新失败，说明有其他线程同时修改了尾指针，会重试该操作。
4）更新成功后，将原尾节点的 next 指针指向新节点。

6.2 出队操作 dequeue：

1）获取当前的头指针 oldHead 和下一个节点 next。
2）如果 next 为空，说明队列为空，返回 false。
3）使用 compare_exchange_strong 原子操作尝试将头指针更新为 next。如果更新成功，将 next 节点的数据赋值给 result（如果 result 不为空），并释放原头节点的内存，返回 true。如果更新失败，说明有其他线程同时修改了头指针，返回 false。

通过这种方式，无锁队列实现了在多线程环境下的入队和出队操作，且不需要使用传统的锁机制

7. 代码说明

7.1. Node 结构体
定义了队列的节点，包含一个数据元素 data 和一个指向下一个节点的原子指针 next。
7.2. LockFreeQueue 类
构造函数：初始化队列的头指针和尾指针，使用一个虚拟节点作为初始状态。
析构函数：清空队列并释放虚拟节点的内存。
enqueue 函数：创建一个新节点，使用 compare_exchange_weak 原子操作将新节点添加到队列尾部。
dequeue 函数：尝试从队列头部移除一个节点，使用 compare_exchange_strong 原子操作确保操作的原子性。
7.3. testLockFreeQueue 函数
创建一个无锁队列，启动多个入队和出队线程，每个线程分别执行 1000 次入队和出队操作。最后等待所有线程完成并输出测试完成信息。
7.4. main 函数
调用 testLockFreeQueue 函数进行测试。

8. 注意事项

1）实现使用了 C++11 及以上的原子操作，确保在多线程环境下的线程安全。
2）实现没有处理内存泄漏问题，在实际应用中可能需要使用更复杂的内存管理技术，如无锁垃圾回收。

C++ 无锁队列：原理与实现
xingyun86的专栏
02-20 624
无锁队列是一种在多线程编程中非常有用的数据结构，通过巧妙地使用原子操作和内存管理，避免了锁的使用，从而提升了性能。本文详细介绍了无锁队列的原理，并给出了完整的 C++ 实现代码及使用示例。希望通过本文的介绍，读者能够深入理解无锁队列的工作机制，并在实际项目中灵活运用这一技术。
C++无锁编程——无锁队列(lock-free queue)
davidhopper的博客
07-16 6475
需要保证对一端的修改是正确的，且对另一端是可见的。(happens-before )关系非常重要，直接关系到能否安全地获取到队列中的数据。队列的挑战与栈的有些不同，因为。这两个指针都是原子变量，从而可在加锁的情形下，可给多个线程同时访问。当有两个线程并发的调用这个函数时，这两个线程就会读取到同一个。，这两个变量占用16字节，而16字节的数据结构需要额外链接原子库。，会新分配两个节点作为虚拟节点③，也会读取到相同的。值④，因此也会同时修改同一个节点，同时设置。关系，就需要在为虚拟节点设置数据项前，更新。
c++的队列与双端队列介绍
最新发布
xihongshi547的博客
04-09 904
本章是对于队列与双端队列的解释与对比，以及两者的用法queue 是一种遵循先进先出（FIFO）原则的数据结构，就像日常生活中排队一样，先到的人先接受服务。在 C++ 里，queue 属于容器适配器，默认以 deque 作为底层容器，不过也能使用 list 来实现。它仅允许在队列的一端（队尾）插入元素，在另一端（队头）删除元素。queue：严格 FIFO，适合需要先进先出的场景（如任务队列、BFS）。deque：双端操作灵活，适合需要动态调整的场景（如滑动窗口、撤销操作）。
C++ 无锁队列
小小的进步
07-03 1656
atomic类型的操作是原子操作，是不可分割的，不能被中断的操作。 程序代码中的一条简单赋值语句会被翻译为多条汇编指令，那么多个线程同时对某一存储单元进行修改，就有可能出现脏数据，原子操作可以避免脏数据的出现。 2. 多线程读写 三、总结 无锁队列依靠原子和CAS操作，对队列的读写索引进行判断来入队和出队，它没有使用互斥量mutex来进行加锁，从性能上具有明显的优势，但同时编程的复杂性增加了很多，在编码时也要对内存序有简单的了解。...
c++ 无锁队列
weixin_39849839的博客
11-23 875
class Queue { private: struct qnode<ElemType> *volatile _head = NULL; // 随着pop后指向的位置是不一样的, head不是固定的 struct qnode<ElemType> *volatile _tail = NULL; public: Queue() { _head = _tail = new qnode<ElemType>; _head->_next =
解析C++无锁队列的实现代码
09-05
下面将详细解析给定的C++无锁队列实现。 首先，我们定义了一个模板类`LockFreeQueue`，它包含一个`std::list`作为底层存储，并提供了`Produce`、`Consume`、`Peek`和`IsEmpty`等方法来完成队列的基本操作。这里的`...
一个c++11实现的无锁队列.zip
11-20
在这个“一个c++11实现的无锁队列”中，我们可以探讨以下几个关键知识点： 1. **无锁编程**：无锁编程是一种并发编程技术，它避免了线程间的竞争条件和死锁问题，通过原子操作保证数据的一致性。在无锁队列中，数据...
无锁队列的C++实现
05-26
一个无锁队列的C++实现。Miscellaneous scripts and things that dont merit their own repo. All under MIT License unless otherwise specified
atomic_queue：C ++无锁队列
01-28
atomic_queue 基于带有循环缓冲区的C ++ 14多生产者多消费者无锁队列。 这些队列遵循的主要设计原理是极简主义：原子操作的最基本要求，固定大小的缓冲区，值语义。 这些品质也有局限性： 最大队列大小必须在编译时或构造时设置。 循环缓冲区以固定缓冲区大小为代价，回避了基于链表的队列中固有的内存回收问题。 有关更多详细信息，请参见。 固定的缓冲区大小可能没有太大的限制，因为一旦队列变得大于最大预期大小，这表明存在元素处理速度不够快的问题，并且如果队列持续增长，它最终可能会消耗所有可用的内存。可能会影响整个系统，而不仅是有问题的过程。 唯一明显的不便之处是，必须对预期或可接受的最大队列大小进行预先的信封后计算。 没有操作系统阻止推送/弹出功能。 此队列是为超低延迟方案设计的，使用OS阻塞原语将牺牲一键弹出延迟。 为了获得尽可能低的延迟，人们无法承受OS内核中的阻塞，因为阻塞线程的唤醒延迟约为1-3微秒，而此队列的往返时间可以低至150纳秒。 超低延迟应用程序仅需此而已。 极简主义带来了回报，请参阅。 可用的容器有： AtomicQueue原子元素的固定大小的环形缓
c++11无锁队列的一种简单实现.pptx
03-08
前一段时间用到了多线程间的共享队列，然后就找到了一种简单实现方式用到项目中，后面在项目组中进行了简单的技术分享，形成了这个ppt。主要用到的是c++11的多线程+原子操作+内存模型方面的知识。
C++实现的无锁队列
aaronjzhang_的专栏
12-06 5507
关于无锁队列的实现，网上有很多的文章，其实现原理都来自论文implementing_lock_free.pdf 国内关于无锁队列实现介绍的较好的博客:http://coolshell.cn/articles/8239.html 关于理论的介绍上述文章已经写的非常好了，因此本文不会复述无锁队列实现原理，只讲解下实现细节以及过程中遇到的问题。 本文实现的是一个多生产者多消费者无锁队列，相比于单生
无锁队列的实现
Hello World!
09-10 1410
原文 http://coolshell.cn/articles/8239.html 关于无锁队列的实现，网上有很多文章，虽然本文可能和那些文章有所重复，但是我还是想以我自己的方式把这些文章中的重要的知识点串起来和大家讲一讲这个技术。下面开始正文。 关于CAS等原子操作 在开始说无锁队列之前，我们需要知道一个很重要的技术就是CAS操作——Compare & Set，或是 Compa
C++实现无锁队列
weixin_42250655的博客
09-14 3419
CAS等原子操作 在介绍无锁队列之前，我们需要知道一个重要的技术就是CAS操作，**现在几乎所有的CPU指令都支持CAS等原子操作。**有了这个原子操作，我们就可以用其来实现各种无锁的数据结构了。 本文用到的是GCC的CAS GCC4.1+版本中支持CAS的原子操作 bool __sync_bool_compare_and_swap (type *ptr, type oldval type newval, ...) type __sync_val_compare_and_swap (type *ptr,
C++ 实现无锁队列——单读单写、多读多写
一枚菜鸡
05-06 1622
之前学习了 C++ 中原子变量的内存顺序，现在我们来看看原子变量和内存顺序的应用 – 无锁队列。本文介绍单写单读和多写多读的无锁队列的简单实现，从中可以看到无锁数据结构设计的一些基本思路。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值