C++编程：无锁环形队列 (LockFreeRingQueue)的简单实现、测试和分析

置顶 已于 2024-08-17 23:42:46 修改
阅读量1.4k 收藏 27
点赞数 31
分类专栏： C++ 性能优化、功能优化 文章标签： c++ 无锁队列 ringbuffer lockfree 无锁
于 2024-08-16 22:31:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stallion5632/article/details/141270923
版权

文章目录

0. 概述

在现代多线程编程中，高效的并发数据结构对于提升系统性能至关重要，尤其是在处理高并发场景时。本文将详细介绍一种无锁环形队列 (LockFreeRingQueue) 的实现，并探讨其在实际应用中的优势与局限。
本文详细测试代码 lock_free_ring_queue

1. 无锁环形队列概述

无锁环形队列是一种高效的并发数据结构，适用于多线程环境下的生产者-消费者模型。它通过使用原子操作（如CAS操作）来避免锁的使用，从而消除了锁竞争带来的性能开销和潜在的死锁风险。

1.1 无锁环形队列的特点

  1. 线程安全：通过原子操作保证数据的正确性。
  2. 高效性：避免了锁竞争，减少了线程上下文切换的开销。
  3. 避免ABA问题：设计时特别考虑了ABA问题的影响，通过合理的索引管理避免了这一问题。

1.2 无锁环形队列的优势与局限

优势：

  1. 高并发性：无锁结构通过避免锁的使用，使多个线程可以并发执行，提高了吞吐量。
  2. 低延迟：在高并发场景下，无锁结构减少了线程竞争带来的上下文切换，降低了系统延迟。
  3. 避免死锁：由于没有锁的存在，自然避免了死锁问题。

局限：

  1. 复杂性：无锁结构通常比锁机制实现更复杂，容易引入难以调试的并发错误。
  2. 硬件依赖性：原子操作（如CAS）通常依赖于底层硬件支持，在不同平台上表现可能有所不同。
  3. 有限应用场景：无锁队列并不适合所有场景，在某些情况下（如低并发或非实时系统），传统的锁机制可能更为适合。

2. LockFreeRingQueue 实现

下面是一个基于C++实现的无锁环形队列的实现，该队列支持多生产者和多消费者线程的并发访问。

#ifndef RING_QUEUE_HPP
#define RING_QUEUE_HPP

#include <atomic>
#include <memory>
#include <stdexcept>
#include <thread>

template <typename T>
class LockFreeRingQueue {
 public:
  // Constructor that initializes the ring queue with the specified size
  explicit LockFreeRingQueue(uint32_t size);

  // Default destructor
  ~LockFreeRingQueue() = default;

  // Disable copy constructor and assignment operator
  LockFreeRingQueue(const LockFreeRingQueue&) = delete;
  LockFreeRingQueue& operator=(const LockFreeRingQueue&) = delete;

  // Enqueue operation to add an element to the queue
  bool Enqueue(const T& data);

  // Dequeue operation to remove an element from the queue
  bool Dequeue(T* data);

  // Check if the queue is empty
  bool IsEmpty() const noexcept;

  // Check if the queue is full
  bool IsFull() const noexcept;

  // Get the current size of the queue
  uint32_t Size() const noexcept;

 private:
  // Check if the given number is a power of two
  static bool IsPowerOfTwo(uint32_t num) noexcept;

  // Calculate the ceiling power of two greater than or equal to the given number
  static uint32_t CeilPowerOfTwo(uint32_t num) noexcept;

  // Round up the given number to the nearest power of two
  static uint32_t RoundupPowerOfTwo(uint32_t num) noexcept;

  // Get the index within the queue
  uint32_t IndexOfQueue(uint32_t index) const noexcept;

 private:
  const uint32_t size_;                     // Size of the queue, must be a power of two
  std::atomic<uint32_t> length_;            // Current length of the queue
  std::atomic<uint32_t> read_index_;        // Index for the consumer to read
  std::atomic<uint32_t> write_index_;       // Index for the producer to write
  std::atomic<uint32_t> last_write_index_;  // Last confirmed write index
  std::unique_ptr<T[]> queue_;              // Array to store the queue elements
};

template <typename T>
LockFreeRingQueue<T>::LockFreeRingQueue(uint32_t size)
    : size_(size <= 1U           ? 2U
            : IsPowerOfTwo(size) ? size
                                 : RoundupPowerOfTwo(size)),
      length_(0U),
      read_index_(0U),
      write_index_(0U),
      last_write_index_(0U),
      queue_(std::make_unique<T[]>(size_)) {
  if (size == 0U) {
    throw std::out_of_range("Queue size must be greater than 0");
  }
}

template <typename T>
bool LockFreeRingQueue<T>::Enqueue(const T& data) {
  uint32_t current_read_index;
  uint32_t current_write_index;

  do {
    current_read_index = read_index_.load(std::memory_order_relaxed);
    current_write_index = write_index_.load(std::memory_order_relaxed);

    // Check if the queue is full
    if (IndexOfQueue(current_write_index + 1U) == IndexOfQueue(current_read_index)) {
      return false;  // Queue is full
    }
  } while (!write_index_.compare_exchange_weak(current_write_index, current_write_index + 1U, std::memory_order_release,
                                               std::memory_order_relaxed));

  queue_[IndexOfQueue(current_write_index)] = data;

  // Confirm the write operation
  while (!last_write_index_.compare_exchange_weak(current_write_index, current_write_index + 1U,
                                                  std::memory_order_release, std::memory_order_relaxed)) {
    std::this_thread::yield();  // Yield CPU to avoid busy-waiting
  }

  length_.fetch_add(1U, std::memory_order_relaxed);

  return true;
}

template <typename T>
bool LockFreeRingQueue<T>::Dequeue(T* data) {
  if (data == nullptr) {
    throw std::invalid_argument("Null pointer passed to Dequeue");
  }

  uint32_t current_read_index;
  uint32_t current_last_write_index;

  do {
    current_read_index = read_index_.load(std::memory_order_relaxed);
    current_last_write_index = last_write_index_.load(std::memory_order_relaxed);

    // Check if the queue is empty
    if (IndexOfQueue(current_last_write_index) == IndexOfQueue(current_read_index)) {
      return false;  // Queue is empty
    }

    *data = queue_[IndexOfQueue(current_read_index)];

    if (read_index_.compare_exchange_weak(current_read_index, current_read_index + 1U, std::memory_order_release,
                                          std::memory_order_relaxed)) {
      length_.fetch_sub(1U, std::memory_order_relaxed);
      return true;
    }
  } while (true);
}

template <typename T>
bool LockFreeRingQueue<T>::IsEmpty() const noexcept {
  return length_.load(std::memory_order_relaxed) == 0U;
}

template <typename T>
bool LockFreeRingQueue<T>::IsFull() const noexcept {
  uint32_t next_write_index = IndexOfQueue(write_index_.load(std::memory_order_relaxed) + 1U);
  return next_write_index == read_index_.load(std::memory_order_acquire);
}

template <typename T>
uint32_t LockFreeRingQueue<T>::Size() const noexcept {
  return length_.load(std::memory_order_relaxed);
}

template <typename T>
bool LockFreeRingQueue<T>::IsPowerOfTwo(uint32_t num) noexcept {
  return (num != 0U) && ((num & (num - 1U)) == 0U);
}

template <typename T>
uint32_t LockFreeRingQueue<T>::CeilPowerOfTwo(uint32_t num) noexcept {
  num |= (num >> 1U);
  num |= (num >> 2U);
  num |= (num >> 4U);
  num |= (num >> 8U);
  num |= (num >> 16U);
  return num - (num >> 1U);
}

template <typename T>
uint32_t LockFreeRingQueue<T>::RoundupPowerOfTwo(uint32_t num) noexcept {
  return CeilPowerOfTwo((num - 1U) << 1U);
}

template <typename T>
uint32_t LockFreeRingQueue<T>::IndexOfQueue(uint32_t index) const noexcept {
  return index & (size_ - 1U);
}

#endif  // RING_QUEUE_HPP

2.1 Enqueue 操作流程图
Full
Not Full
Success
Fail
Success
Fail
Start enQueue
Check if Full
Return false
CAS Update Write Index
Write Data
CAS Update Last Write Index
Increment Length
End enQueue
Yield Thread

2.2 Dequeue 操作流程图
Empty
Not Empty
Success
Fail
Start deQueue
Check if Empty
Return false
Read Data from Queue
CAS Update Read Index
Decrement Length
End deQueue

3. 核心实现细节

3.1 环形队列的大小调整

环形队列的大小通常为2的幂次，以便可以通过位运算快速计算索引。RoundUpPowerOfTwo 函数将任意正整数向上调整为最接近的2的幂次。

确保环形队列的大小是 2 的幂次方主要有以下几个原因:

  • 简化索引计算:

    • 在环形队列中,元素的位置通过取模运算来计算。
    • 如果队列的大小是 2 的幂次方,那么取模运算可以被位运算 & 替代,这个操作更加高效。

  • 避免对齐问题:

    • 对于某些硬件架构来说,内存访问的效率会受到内存对齐的影响。
    • 如果队列大小是 2 的幂次方,那么它就能很好地符合内存对齐要求,从而提高访问效率。

  • 位操作优化:

    • 很多处理器都针对 2 的幂次方大小的数据提供了优化的指令集。
    • 比如,判断一个数是否是 2 的幂次方可以用位操作 (num & (num - 1)) == 0 来实现,这比普通的除法要高效得多。

  • 缓存友好性:

    • 当队列大小是 2 的幂次方时,元素在内存中的分布更加规则有序。
    • 这有利于利用缓存,减少缓存未命中的情况,提高整体性能。

3.2 索引计算

通过IndexOfQueue 函数，索引计算可以使用位与操作（&）而不是取模运算（%），从而提升计算速度。

3.3 原子操作与CAS

通过 std::atomic_compare_exchange_weak 原子操作实现无锁队列的核心逻辑。CAS（Compare-And-Swap）是无锁数据结构的基础，用于确保多个线程在修改共享数据时不会引发数据竞争。

3.4 线程让步

在 Enqueue 操作中，当多个线程尝试修改相同的共享变量时，失败的线程可以选择让出CPU时间片，以减少竞争和等待时间。

4. 测试示例程序

下面是一个简单的C++示例程序，演示了如何使用 LockFreeRingQueue 类。该程序将进行一些基本的入队和出队操作，然后在多线程环境下测试队列的使用。

4.1 实现代码

#include <iostream>
#include <thread>

#include "lock_free_ring_queue.h"  // 假设你的类定义在这个文件中

void SingleProducerSingleConsumerExample() {
  LockFreeRingQueue<int> queue(4);

  // 单生产者线程入队
  std::thread producer([&queue]() {
    for (int i = 0; i < 4; ++i) {
      if (queue.Enqueue(i)) {
        std::cout << "Producer enqueued: " << i << std::endl;
      } else {
        std::cout << "Queue is full, cannot enqueue: " << i << std::endl;
      }
    }
  });

  // 单消费者线程出队
  std::thread consumer([&queue]() {
    int value = 0;
    for (int i = 0; i < 4; ++i) {
      while (!queue.Dequeue(&value)) {
        std::this_thread::yield();  // 等待队列中有数据
      }
      std::cout << "Consumer dequeued: " << value << std::endl;
    }
  });

  producer.join();
  consumer.join();
}

void MultiProducerMultiConsumerExample() {
  LockFreeRingQueue<int> queue(8);

  auto producer = [&queue](int id) {
    for (int i = 0; i < 4; ++i) {
      int value = id * 10 + i;
      if (queue.Enqueue(value)) {
        std::cout << "Producer " << id << " enqueued: " << value << std::endl;
      } else {
        std::cout << "Queue is full, Producer " << id << " cannot enqueue: " << value << std::endl;
      }
    }
  };

  auto consumer = [&queue](int id) {
    int value = 0;
    for (int i = 0; i < 4; ++i) {
      while (!queue.Dequeue(&value)) {
        std::this_thread::yield();  // 等待队列中有数据
      }
      std::cout << "Consumer " << id << " dequeued: " << value << std::endl;
    }
  };

  std::thread producers[2];
  std::thread consumers[2];

  // 启动两个生产者线程
  for (int i = 0; i < 2; ++i) {
    producers[i] = std::thread(producer, i);
  }

  // 启动两个消费者线程
  for (int i = 0; i < 2; ++i) {
    consumers[i] = std::thread(consumer, i);
  }

  for (auto &producer : producers) {
    producer.join();
  }

  for (auto &consumer : consumers) {
    consumer.join();
  }
}

int main() {
  std::cout << "Single Producer, Single Consumer Example:" << std::endl;
  SingleProducerSingleConsumerExample();

  std::cout << "\nMulti Producer, Multi Consumer Example:" << std::endl;
  MultiProducerMultiConsumerExample();

  return 0;
}

4.2 代码解释：

  • SingleProducerSingleConsumerExample:

    • 创建了一个大小为 4 的队列。

    • 使用一个生产者线程将数字 0-3 入队。

    • 使用一个消费者线程从队列中出队并打印结果。

  • MultiProducerMultiConsumerExample:

    • 创建了一个大小为 8 的队列。

    • 启动两个生产者线程，每个线程将其线程 ID 和循环计数拼接成值并入队。

    • 启动两个消费者线程，从队列中出队并打印结果。

4.3 运行程序：

将上面的代码保存为 main.cpp，并确保你已经编译和链接了 LockFreeRingQueue 类的实现。

编译示例：

g++ -std=c++14 main.cpp -pthread -o lock_free_ring_queue_example
./lock_free_ring_queue_example

4.4 执行结果：

$ ./lock_free_ring_queue_example 
Single Producer, Single Consumer Example:
Producer enqueued: Consumer dequeued: 0
0
Producer enqueued: 1
Producer enqueued: 2
Producer enqueued: 3
Consumer dequeued: 1
Consumer dequeued: 2
Consumer dequeued: 3

Multi Producer, Multi Consumer Example:
Producer 0 enqueued: 0
Producer 0 enqueued: 1
Producer 0 enqueued: 2
Producer 0 enqueued: 3
Consumer 1 dequeued: 0
Consumer 1 dequeued: 1
Consumer 1 dequeued: 2
Consumer 1 dequeued: 3
Producer 1 enqueued: 10
Producer 1 enqueued: 11
Producer 1 enqueued: 12
Producer 1 enqueued: 13
Consumer 0 dequeued: 10
Consumer 0 dequeued: 11
Consumer 0 dequeued: 12
Consumer 0 dequeued: 13

5. 单元测试

下面是使用gtest编写的LockFreeRingQueue类的完整单元测试。测试涵盖了基本功能，包括队列的初始化、入队、出队、边界条件，以及在多线程环境下的行为。

#include "lock_free_ring_queue.h"  // 假设你的类定义在这个文件中
#include <gtest/gtest.h>

#include <algorithm>
#include <memory>
#include <thread>
#include <vector>

class LockFreeRingQueueTest : public ::testing::Test {
 protected:
  void SetUp() override {
    // 初始化队列大小
    queue_size_ = 64;
    queue_ = std::make_unique<LockFreeRingQueue<int>>(queue_size_);
  }

  std::unique_ptr<LockFreeRingQueue<int>> queue_;
  uint32_t queue_size_;
};

// 测试队列初始化
TEST_F(LockFreeRingQueueTest, Initialization) {
  EXPECT_EQ(queue_->Size(), 0U);
  EXPECT_TRUE(queue_->IsEmpty());
}

// 测试入队和出队单个元素
TEST_F(LockFreeRingQueueTest, SingleEnqueueDequeue) {
  int value_in = 42;
  int value_out = 0;

  EXPECT_TRUE(queue_->Enqueue(value_in));
  EXPECT_EQ(queue_->Size(), 1U);
  EXPECT_FALSE(queue_->IsEmpty());

  EXPECT_TRUE(queue_->Dequeue(&value_out));
  EXPECT_EQ(value_out, value_in);
  EXPECT_EQ(queue_->Size(), 0U);
  EXPECT_TRUE(queue_->IsEmpty());
}

// 测试队列满时入队
TEST_F(LockFreeRingQueueTest, EnqueueFullQueue) {
  for (uint32_t i = 0; i < queue_size_ - 1; ++i) {  // 注意减1
    EXPECT_TRUE(queue_->Enqueue(static_cast<int>(i)));
  }

  EXPECT_EQ(queue_->Size(), queue_size_ - 1);
  EXPECT_FALSE(queue_->Enqueue(100));  // 队列已满，入队失败
}

// 测试空队列出队
TEST_F(LockFreeRingQueueTest, DequeueEmptyQueue) {
  int value_out = 0;
  EXPECT_FALSE(queue_->Dequeue(&value_out));  // 队列为空，出队失败
}

// 多线程测试
TEST_F(LockFreeRingQueueTest, MultiThreadedEnqueueDequeue) {
  const int num_threads = 4;
  const int num_elements_per_thread = 10;

  auto enqueue_function = [&](int thread_id) {
    for (int i = 0; i < num_elements_per_thread; ++i) {
      queue_->Enqueue(thread_id * num_elements_per_thread + i);
    }
  };

  auto dequeue_function = [&](int thread_id, int* result_array) {
    for (int i = 0; i < num_elements_per_thread; ++i) {
      int value = 0;
      while (!queue_->Dequeue(&value)) {
        std::this_thread::yield();
      }
      result_array[thread_id * num_elements_per_thread + i] = value;
    }
  };

  std::vector<std::thread> threads;
  int results[num_threads * num_elements_per_thread] = {0};

  for (int i = 0; i < num_threads; ++i) {
    threads.emplace_back(enqueue_function, i);
  }

  for (auto& thread : threads) {
    thread.join();
  }

  threads.clear();

  for (int i = 0; i < num_threads; ++i) {
    threads.emplace_back(dequeue_function, i, results);
  }

  for (auto& thread : threads) {
    thread.join();
  }

  EXPECT_EQ(queue_->Size(), 0U);
  EXPECT_TRUE(queue_->IsEmpty());

  // 检查所有元素是否都已被成功出队
  std::sort(std::begin(results), std::end(results));
  for (int i = 0; i < num_threads * num_elements_per_thread; ++i) {
    EXPECT_EQ(results[i], i);
  }
}

// 边界条件测试：初始化大小为1的队列
TEST(LockFreeRingQueueBoundaryTest, InitializationWithSizeOne) {
  LockFreeRingQueue<int> small_queue(1);

  EXPECT_EQ(small_queue.Size(), 0U);
  EXPECT_TRUE(small_queue.IsEmpty());

  int value_in = 99;
  EXPECT_TRUE(small_queue.Enqueue(value_in));
  EXPECT_FALSE(small_queue.Enqueue(value_in));  // 队列应该已经满了
}

// 边界条件测试：入队和出队仅一个元素
TEST(LockFreeRingQueueBoundaryTest, SingleElementQueue) {
  LockFreeRingQueue<int> small_queue(1);

  int value_in = 123;
  int value_out = 0;

  EXPECT_TRUE(small_queue.Enqueue(value_in));
  EXPECT_FALSE(small_queue.Enqueue(value_in));  // 队列已满

  EXPECT_TRUE(small_queue.Dequeue(&value_out));
  EXPECT_EQ(value_out, value_in);

  EXPECT_FALSE(small_queue.Dequeue(&value_out));  // 队列为空
}

int main(int argc, char** argv) {
  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}

5.1 测试代码解释：

  • 基本功能测试：

    • Initialization: 检查队列是否正确初始化。

    • SingleEnqueueDequeue: 测试单个元素的入队和出队操作。

    • EnqueueFullQueue: 测试在队列已满时的入队操作。

    • DequeueEmptyQueue: 测试在队列为空时的出队操作。

  • 多线程测试：

    • MultiThreadedEnqueueDequeue: 使用多个线程测试队列的入队和出队操作。每个线程分别执行入队和出队操作，最后检查所有元素是否正确出队。

  • 边界条件测试：

    • InitializationWithSizeOne: 测试初始化大小为1的队列。

    • SingleElementQueue: 测试大小为1的队列的入队和出队操作。

5.2 测试运行：

将上面的代码保存为一个测试文件（例如lock_free_ring_queue_test.cpp），并确保你已经安装了gtest库。然后编译并运行测试。

编译示例：

g++ -std=c++14 lock_free_ring_queue_test.cpp -lgtest -lgtest_main -pthread -o lock_free_ring_queue_test
./lock_free_ring_queue_test

测试结果：

$ ./lock_free_ring_queue_test 
[==========] Running 7 tests from 2 test suites.
[----------] Global test environment set-up.
[----------] 5 tests from LockFreeRingQueueTest
[ RUN      ] LockFreeRingQueueTest.Initialization
[       OK ] LockFreeRingQueueTest.Initialization (0 ms)
[ RUN      ] LockFreeRingQueueTest.SingleEnqueueDequeue
[       OK ] LockFreeRingQueueTest.SingleEnqueueDequeue (0 ms)
[ RUN      ] LockFreeRingQueueTest.EnqueueFullQueue
[       OK ] LockFreeRingQueueTest.EnqueueFullQueue

 (0 ms)
[ RUN      ] LockFreeRingQueueTest.DequeueEmptyQueue
[       OK ] LockFreeRingQueueTest.DequeueEmptyQueue (0 ms)
[ RUN      ] LockFreeRingQueueTest.MultiThreadedEnqueueDequeue
[       OK ] LockFreeRingQueueTest.MultiThreadedEnqueueDequeue (10 ms)
[----------] 5 tests from LockFreeRingQueueTest (10 ms total)

[----------] Global test environment tear-down
[==========] 7 tests from 2 test suites ran. (10 ms total)
[  PASSED  ] 7 tests.

6. 总结

无锁环形队列在高并发场景下具有显著的性能优势，其设计充分利用了现代硬件提供的原子操作和内存模型。然而，在实际应用中，开发者需要权衡无锁结构带来的复杂性和潜在的硬件依赖问题。

橘色的喵
关注
专栏目录
C++无锁队列
weixin_43804370的博客
04-15 4880
利用原子操作基于c++语言实现的无锁队列
C++  并发无锁队列的原理与实现
yxh_1_的博客
04-21 3388
C++ 并发无锁队列的原理与实现 一般无锁队列的情况分为两种，第一种是单个消费者与单个生产者，第二种是多个消费者或者多个生产着的情况。 一.单个消费者与单个生产者的情况 这种情况下可以用环形队列RingBuffer来实现无锁队列，比如dpdk和kfifo的无锁队列就是用环形队列实现的，kfifo里面的入队和出队的处理很巧妙，大家可以去看看。 DPDK：https://blog.csdn.net/s2603898260/article/details/109565922 KFIFO：https://b.
无锁消息队列实现-课件1
08-03
锁消息队列实现-课件为什么需要锁队列Cache损坏(Cache trashing)在同步机制上的争抢队列动态内存分配锁队列的实现原操作函数类接和变量数据结构逻辑
C++实现无锁队列
weixin_42250655的博客
09-14 3221
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++ 无锁队列
小米的修行之路
02-25 1035
1、老外写的一个无锁队列，适用于单生产者和单消费者的情况。我们可以使用，避免重复造轮子。 下载地址：https://github.com/cameron314/readerwriterqueue 2、简单的测试： // NO_LOCK_QUEUE_TEST.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include <iostream> ...
c++ 无锁队列
weixin_39849839的博客
11-23 815
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++实现的无锁环形队列
11-05
1. c++实现的无锁环形队列，注释详细，讲解了环形队列的实现原理和操作技巧 2. 在linux服务器下，可以自己编译，运行，也可以修改参数后做测试 3. 编译的命令如下：g++ -std=c++11 -o test main.cpp ring_buffer.cpp...
解析C++无锁队列的实现代码
09-05
在C++中，实现无锁队列的关键在于利用原子操作（Atomic Operations）来保证数据在并发环境中的正确性。下面将详细解析给定的C++无锁队列实现。 首先，我们定义了一个模板类`LockFreeQueue`，它包含一个`std::list`...
无锁单生产者-单消费者循环队列
04-11
标题 "无锁单生产者-单消费者循环队列" 涉及到的是并发编程中的一个高级主题，它探讨了如何在多线程环境中高效地实现数据共享，尤其是在C++11标准下。C++11引入了许多新的特性，如线程库（）、原子操作（）等，使得...
无锁队列的C++实现
05-26
一个无锁队列的C++实现。Miscellaneous scripts and things that dont merit their own repo. All under MIT License unless otherwise specified
[c++]无锁队列
I have a adream
10-01 739
/* * 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 */ #
C++实现的无锁队列
aaronjzhang_的专栏
12-06 5299
关于无锁队列的实现，网上有很多的文章，其实现原理都来自论文implementing_lock_free.pdf 国内关于无锁队列实现介绍的较好的博客:http://coolshell.cn/articles/8239.html 关于理论的介绍上述文章已经写的非常好了，因此本文不会复述无锁队列实现原理，只讲解下实现细节以及过程中遇到的问题。 本文实现的是一个多生产者多消费者无锁队列，相比于单生
C++无锁编程——无锁队列(lock-free queue)
最新发布
davidhopper的博客
07-16 4466
需要保证对一端的修改是正确的，且对另一端是可见的。(happens-before )关系非常重要，直接关系到能否安全地获取到队列中的数据。队列的挑战与栈的有些不同，因为。这两个指针都是原子变量，从而可在加锁的情形下，可给多个线程同时访问。当有两个线程并发的调用这个函数时，这两个线程就会读取到同一个。，这两个变量占用16字节，而16字节的数据结构需要额外链接原子库。，会新分配两个节点作为虚拟节点③，也会读取到相同的。值④，因此也会同时修改同一个节点，同时设置。关系，就需要在为虚拟节点设置数据项前，更新。
C++无锁队列实现 (2012-05-15 07:46:26)
pi9nc的专栏
07-04 1101
转载▼ 标签：  c无锁队列   线程安全队列   it 分类： 常用源码 本文给出一种C++无锁队列的实现代码，主要用于一个线程读取数据另外一个线程写数据   #ifndef LOCK_FREE_QUEUE_H_ #define LOCK_FREE_QUEUE_H_   //不加锁队列，适合一个
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

橘色的喵

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

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

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

打赏作者

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

抵扣说明：

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

余额充值