【CPP】单生产者单消费者无锁队列使用记录

已于 2024-08-24 22:56:52 修改
阅读量531 收藏 5
点赞数 2
分类专栏： # CPP 文章标签： c++ lock free queue 无锁队列 queue
于 2024-08-24 22:51:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zhy29563/article/details/141506261
版权

无锁队列地址：https://github.com/cameron314/readerwriterqueue

该仓库提供三种队列：

  • 无锁队列
  • 带阻塞与超时的无锁队列
  • 无锁环形缓存
    以下通过三个官方例子与简要说明进行阐述。

1. 无锁队列

1.1 打印输出函数

#include <readerwriterqueue.h>
#include <iostream>

template <class T>
void PrintQueue(moodycamel::ReaderWriterQueue<T>& queue, const char* description = nullptr) {
  std::cout << "------------------------------------------------ " << std::endl;
  std::cout << "description  : " << description << std::endl;
  std::cout << "max_capacity : " << queue.max_capacity() << std::endl;
  std::cout << "size_approx  : " << queue.size_approx() << std::endl;
  std::cout << "peek address : " << queue.peek() << std::endl;
  T    element;
  bool succeeded;
  while (queue.size_approx() > 0) {
    succeeded = queue.try_dequeue(element);
    if (succeeded) {
      std::cout << element << " ";
    }
  }
  std::cout << std::endl;
}

1.2 查看基本信息

{
  // 默认构造
  moodycamel::ReaderWriterQueue<int> q;  // max_capacity: 15
  PrintQueue(q, "default");

  // 有参构造，查看最大容量
  moodycamel::ReaderWriterQueue<int> q3(3);  // max_capacity: 3
  PrintQueue(q3, "3");

  // 有参构造，查看最大容量
  moodycamel::ReaderWriterQueue<int> q5(5);  // max_capacity: 7
  PrintQueue(q5, "5");
}

输出：

------------------------------------------------ 
description  : default
max_capacity : 15
size_approx  : 0
peek address : 0

------------------------------------------------ 
description  : 3
max_capacity : 3
size_approx  : 0
peek address : 0

------------------------------------------------ 
description  : 5
max_capacity : 7
size_approx  : 0
peek address : 0

注意
如果给定的容量大小为2^n -1，则容量为指定值；否则，容量为大于给定值且最小的2^n-1

1.3 插入元素

1.3.1 enqueue/emplace

{
  moodycamel::ReaderWriterQueue<int> q(3);
  PrintQueue(q, "init");

  for (int index = 0; index < 5; index++) {
    // q.enqueue(index);
    q.emplace(index);
  }
  PrintQueue(q, "enqueue/emplace");  // 0 1 2 3 4 5 6 7
}

输出：

------------------------------------------------ 
description  : init
max_capacity : 3
size_approx  : 0
peek address : 0

------------------------------------------------ 
description  : enqueue/emplace
max_capacity : 10
size_approx  : 5
peek address : 0x7e5ca0
0 1 2 3 4

注意
函数enqueue/emplace在队列满后，会分配新的空间以存放插入元素。队列的容量会发生变化。这里仅验证了二次分配的规律：

指定大小容量大小二次分配容量大小
3310
5722
91546

二次分配的容量为首次分配容量的三倍减一，即3n-1

1.3.2 try_enqueue/try_emplace

{
  moodycamel::ReaderWriterQueue<int> q(5);
  for (int index = 0; index < 10; index++) {
    // q.try_emplace(index);
    if (!q.try_enqueue(index)) {
      std::cout << "Insert element is failed, element: " << index << std::endl;
    }
  }
  PrintQueue(q, "try_enqueue/try_emplace");  // 0 1 2 3 4 5 6
}

输出

Insert element is failed, element: 7
Insert element is failed, element: 8
Insert element is failed, element: 9
------------------------------------------------ 
description  : try_enqueue/try_emplace
max_capacity : 7
size_approx  : 7
peek address : 0x725ca0
0 1 2 3 4 5 6

注意
函数try_enqueue/try_emplace在队列满时，不会分配新的空间以存储插入元素。插入元素被丢弃。

1.4 完整代码

#include <readerwriterqueue.h>

#include <iostream>

template <class T>
void PrintQueue(moodycamel::ReaderWriterQueue<T>& queue, const char* description = nullptr) {
  std::cout << "------------------------------------------------ " << std::endl;
  std::cout << "description  : " << description << std::endl;
  std::cout << "max_capacity : " << queue.max_capacity() << std::endl;
  std::cout << "size_approx  : " << queue.size_approx() << std::endl;
  std::cout << "peek address : " << queue.peek() << std::endl;
  T    element;
  bool succeeded;
  while (queue.size_approx() > 0) {
    succeeded = queue.try_dequeue(element);
    if (succeeded) {
      std::cout << element << " ";
    }
  }
  std::cout << std::endl;
}

int main() {
  {
    // 默认构造
    moodycamel::ReaderWriterQueue<int> q;  // max_capacity: 15
    PrintQueue(q, "default");

    // 有参构造，查看最大容量
    moodycamel::ReaderWriterQueue<int> q3(3);  // max_capacity: 3
    PrintQueue(q3, "3");

    // 有参构造，查看最大容量
    moodycamel::ReaderWriterQueue<int> q5(5);  // max_capacity: 7
    PrintQueue(q5, "5");
  }

  {
    moodycamel::ReaderWriterQueue<int> q(5);
    for (int index = 0; index < 10; index++) {
      // q.try_emplace(index);
      if (!q.try_enqueue(index)) {
        std::cout << "Insert element is failed, element: " << index << std::endl;
      }
    }
    PrintQueue(q, "try_enqueue/try_emplace");  // 0 1 2 3 4 5 6
  }

  {
    moodycamel::ReaderWriterQueue<int> q(3);
    PrintQueue(q, "init");

    for (int index = 0; index < 5; index++) {
      // q.enqueue(index);
      q.emplace(index);
    }
    PrintQueue(q, "enqueue/emplace");  // 0 1 2 3 4 5 6 7
  }

  return EXIT_SUCCESS;
}

2. 带阻塞与超时的无锁队列

基本使用与无所队列相同，提供了额外的阻塞函数。

#include <readerwriterqueue.h>

#include <iostream>

template <class T>
void PrintQueue(moodycamel::BlockingReaderWriterQueue<T>& queue, const char* description = nullptr) {
  std::cout << "------------------------------------------------ " << std::endl;
  std::cout << "description  : " << description << std::endl;
  std::cout << "max_capacity : " << queue.max_capacity() << std::endl;
  std::cout << "size_approx  : " << queue.size_approx() << std::endl;
  std::cout << "peek address : " << queue.peek() << std::endl;

  T    element;
  bool succeeded;
  while (queue.size_approx() > 0) {
    succeeded = queue.try_dequeue(element);
    if (succeeded) {
      std::cout << element << " ";
    }
  }
  std::cout << std::endl;
}

int main() {
  {
    moodycamel::BlockingReaderWriterQueue<int> q;  // max_capacity: 15
    PrintQueue(q, "default");

    moodycamel::BlockingReaderWriterQueue<int> q3(3);  // max_capacity: 3
    PrintQueue(q3, "3");

    moodycamel::BlockingReaderWriterQueue<int> q5(5);  // max_capacity: 7
    PrintQueue(q5, "5");
  }

  {
    moodycamel::BlockingReaderWriterQueue<int> q(5);
    for (int index = 0; index < 8; index++) {
      // q.enqueue(index);
      q.emplace(index);
    }
    PrintQueue(q, "enqueue/emplace");  // 0 1 2 3 4 5 6 7
  }

  {
    moodycamel::BlockingReaderWriterQueue<int> q(5);
    for (int index = 0; index < 8; index++) {
      // q.try_emplace(index);
      if (!q.try_enqueue(index)) {
        std::cout << "Insert element is failed, element: " << index << std::endl;
      }
    }
    PrintQueue(q, "try_enqueue/try_emplace");  // 0 1 2 3 4 5 6
  }

  {
    moodycamel::BlockingReaderWriterQueue<int> q(5);
    for (int index = 0; index < 8; index++) {
      q.emplace(index);
    }

    int element1;
    q.wait_dequeue(element1);  // 如果队列为空，函数会阻塞到队列非空

    int  element2;
    if (q.wait_dequeue_timed(element2, 5)) {  // 如果队列为空，函数会阻塞到超时结束，然后返回false
      std::cout << "element2: " << element2 << std::endl;
    }

    PrintQueue(q, "wait_dequeue/wait_dequeue_timed");
  }

  return EXIT_SUCCESS;
}

3. 无锁环形缓存

#include <readerwritercircularbuffer.h>

#include <iostream>

template <class T>
void PrintQueue(moodycamel::BlockingReaderWriterCircularBuffer<T>& queue, const char* description = nullptr) {
  std::cout << "------------------------------------------------ " << std::endl;
  std::cout << "description  : " << description << std::endl;
  std::cout << "max_capacity : " << queue.max_capacity() << std::endl;
  std::cout << "size_approx  : " << queue.size_approx() << std::endl;

  T    element;
  bool succeeded;
  while (queue.size_approx() > 0) {
    succeeded = queue.try_dequeue(element);
    if (succeeded) {
      std::cout << element << " ";
    }
  }
  std::cout << std::endl;
}

int main() {
  {
    moodycamel::BlockingReaderWriterCircularBuffer<int> q3(3);  // max_capacity: 3
    PrintQueue(q3, "3");

    moodycamel::BlockingReaderWriterCircularBuffer<int> q5(5);  // max_capacity: 5
    PrintQueue(q5, "5");

    // 容量为指定位置
  }

  {
    moodycamel::BlockingReaderWriterCircularBuffer<int> q(5);
    for (int index = 0; index < 8; index++) {
      if (!q.try_enqueue(index)) {  // 如果插入元素时，队列已满，则丢弃
        std::cout << "Insert element is failed, element: " << index << std::endl;
      }
    }
    PrintQueue(q, "try_enqueue");  // 0 1 2 3 4
  }

  {
    moodycamel::BlockingReaderWriterCircularBuffer<int> q(5);
    for (int index = 0; index < 8; index++) {
      if (!q.wait_enqueue_timed(index, 5)) {  // 队列已满且在指定的超时时间内未获得存储空间，则插入失败，元素被丢弃
        std::cout << "Insert element is failed, element: " << index << std::endl;
      }
    }
    PrintQueue(q, "wait_enqueue_timed");  // 0 1 2 3 4
  }

  {
    moodycamel::BlockingReaderWriterCircularBuffer<int> q(5);
    for (int index = 0; index < 8; index++) {
      q.try_enqueue(index);
    }

    int element1;
    q.wait_dequeue(element1);
    std::cout << "wait_dequeue->element1: " << element1 << std::endl;

    int  element2;
    if (q.wait_dequeue_timed(element2, std::chrono::milliseconds(1))) {
      std::cout << "element2: " << element2 << std::endl;
    }

    PrintQueue(q, "wait_dequeue/wait_dequeue_timed");  // 2 3 4
  }

  return EXIT_SUCCESS;
}
C++无锁队列
weixin_43804370的博客
04-15 5040
利用原子操作基于c++语言实现的无锁队列
无锁队列之单生产者单消费者
kakaxi679的专栏
12-19 2026
现实应用场景中经常会用到单生产者单消费者或多生产者多消费者模型，例如一个写线程，接收到数据写入缓冲区，另一个线程读出并处理。为了尽可能减少锁所占用的时间，可使用gcc的一些原子操作来代替pthread_mutex_t或pthread_spinlock_t。实现如下：#ifndef SPSC_H #define SPSC_H //single producer single consumer#incl
cpp-一个快速多生产者多消费者的C11无锁并发队列
08-15
一个快速多生产者，多消费者的C 11无锁并发队列
C++无锁编程——无锁队列(lock-free queue)
davidhopper的博客
07-16 6507
需要保证对一端的修改是正确的，且对另一端是可见的。(happens-before )关系非常重要，直接关系到能否安全地获取到队列中的数据。队列的挑战与栈的有些不同，因为。这两个指针都是原子变量，从而可在加锁的情形下，可给多个线程同时访问。当有两个线程并发的调用这个函数时，这两个线程就会读取到同一个。，这两个变量占用16字节，而16字节的数据结构需要额外链接原子库。，会新分配两个节点作为虚拟节点③，也会读取到相同的。值④，因此也会同时修改同一个节点，同时设置。关系，就需要在为虚拟节点设置数据项前，更新。
C++编程： 解读无锁队列(Lock-Free)的原理、实现和实例
Where there is life, there is hope.
08-01 2343
本文将基于几篇无锁队列(Lock-Free)技术文章阐述无锁队列的原理并推荐开源无锁队列库
concurrentqueue：C ++ 11的快速多生产者，多消费者，无锁的并发队列
02-18
注意：如果您需要的只是一个单一生产者，单一消费者队列，那么我也可以选择。 特征 击倒你的。 单头实现。 只需将其放入您的项目中即可。 完全线程安全的无锁队列。 从任何数量的线程同时使用。 C ++ 11实现-尽...
用c++ 11编写的有界的单生产者单消费者无等待和无锁队列- rigtorp/SPSCQueue
01-27
综上所述，rigtorp/SPSCQueue是一个使用C++11特性构建的、高效且线程安全的单生产者单消费者无锁队列。其特点是无等待、无锁、仅通过头文件使用，并且专为并发环境设计。对于需要在多线程环境中高效传输数据的C++...
单生产者/单消费者 的 FIFO 无锁队列
weixin_30783913的博客
06-30 1077
  发现 zeromq 的 yqueue_t 模板类，其数据存储理念设计得非常妙。借这一理念，按照 STL 的泛型类 queue 的接口标准，我设计了一个线程安全的 单生产者/单消费者（单线程push/单线程pop） FIFO 队列，以此满足更为广泛的应用。 1. 数据存储理念的结构图 队列的整体结构上，使用链表的方式，将多个固定长度的 chunk 串联起来； 每个 chunk 则可用于存储...
198_C++\C_详细解析无锁队列的应用，基于CAS封装的无锁List【用到了CAS无锁策略，有点类似乐观锁的意思】
HanLongXia的博客
12-11 988
//**bool** __sync_bool_compare_and_swap(type *ptr, type oldval type newval, ...) //type __sync_val_compare_and_swap(type *ptr, type oldval type newval, ...) #include <algorithm> #include <vector> #include <string> #include <unordered
readerwriterqueue无锁生产者消费者测试源码
12-29
readerwriterqueue无锁生产者消费者测试源码。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
readerwriterqueue C++单生产者，单消费者无锁队列
yp18792574062的博客
01-05 3423
1、readerwriterqueue C++单生产者，单消费者无锁队列，它只支持两个线程用例，一个用于生产，一个用于消费 github地址：https://github.com/cameron314/readerwriterqueue 2、优点 快速 兼容C++11标准 就像std::queue一样，你不需要为元素分配内存 在连续块中预先分配内存 提供一种try_enqueue...
并发无锁队列学习（单生产者单消费者模型）
ZP1015
07-24 5195
【摘要】本文介绍单生产者单消费者模型的队列。根据写入队列的内容是定长还是变长，分为单生产者单消费者定长队列和单生产者单消费者变长队列两种。单生产者单消费者模型的队列操作过程是不需要进行加锁的。生产者通过写索引控制入队操作，消费者通过读索引控制出队列操作。二者相互之间对索引是独享，不存在竞争关系。
数据结构之单生产单消费无锁队列
qq_21376463的博客
05-20 822
当我们编译时开启优化（VS编译使用Release，g++编译开启O2或O3），很显然并不会打印23行的结果，这是因为变量_write已经被写入寄存器，而且我们一直是死循环读取变量_write，所以寄存器不会被更新；volatile的使用网上有很多介绍，这里表示每次读取变量_write，都会从内存读取数据，而不会使用寄存器缓存。聪明的小伙伴此时一定会想到我想表达的问题，即sc_sp_queue的_write和_read同样需要volatile修饰。5、考虑使用模板实现，以满足不同数据类型的需要；
C++ 实现的单生产者和单消费者的lock-free 队列
二分掌柜的
06-29 467
flyfish
C++并发编程之普通无锁队列与单生成者单消费者队列
最新发布
捕鲸叉的专栏
01-14 365
在C++并发编程中，无锁队列是一种常见的并发数据结构，可以用于多线程环境下的高效数据传递。下面将分别介绍一种普通无锁队列和一种单生产者单消费者（SPSC, Single Producer Single Consumer）无锁队列的设计思路，并提供相应的代码实现
单生产者单消费者模式的无锁队列实现
无语的阿辉
10-28 1562
#ifndef FIFO_H #define FIFO_H struct FIFO { void **buffer; unsigned int size; unsigned int in; unsigned int out; }; struct FIFO *FIFO_alloc(unsigned int size); unsigned int FIFO_put
c++ 高并发队列的实现
BBinChina的专栏
09-11 2148
JAVA如何进行CAS 讲到java的队列时，讲到java中的CAS操作 回顾下java中的cas，主要采用compareAndSet方法，如AtomicReference中所使用的： AtomicRefrence.java /** * Atomically sets the value to the given updated value * if the current value {@code ==} the expected value. * @param expect
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhy29563

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值