百度360必应搜狗淘宝本站头条
vba高级教程svn连接scheduledtaskmybatis plus结构体数组
当前位置：网站首页 > 编程网 > 正文

Boost高性能并发无锁队列指南:boost::lockfree::queue

yuyutoo 2025-04-07 20:58 7 浏览 0 评论

1. 库的介绍

boost::lockfree::queue是Boost C++库中lockfree模块的一部分，它提供了一个线程安全的无锁队列实现。无锁队列允许多个线程在不使用互斥锁的情况下并发地访问共享数据结构，从而避免了传统锁带来的线程阻塞和上下文切换开销。

该组件位于Boost库的boost/lockfree/queue.hpp头文件中，要使用它需要先安装Boost库（1.53.0版本以上），并包含相应的头文件：

 #include <boost/lockfree/queue.hpp>
 #include 
 #include 
 #include

2. 主要功能与特点

2.1 主要功能

  • 线程安全：多线程环境下无需额外同步机制
  • 先进先出(FIFO)队列：保证数据按顺序处理
  • 多生产者多消费者(MPMC)支持：适用于复杂并发场景
  • 无阻塞操作：入队和出队操作不会阻塞线程
  • 容量配置：支持固定大小和动态大小队列

2.2 特点

  • 高性能：相比互斥锁实现，在高并发情况下性能显著提升
  • 无死锁风险：不使用锁，因此不存在死锁问题
  • 适合实时系统：操作延迟低且可预测
  • 内存一致性：提供良好的内存序保证
  • ABA问题的解决：内部实现解决了无锁编程中的ABA问题

3. 应用场景

boost::lockfree::queue特别适合以下场景：

  • 高性能计算：需要线程间快速数据交换的场景
  • 实时系统：对延迟敏感的应用程序
  • 消息传递系统：作为线程间通信的媒介
  • 生产者-消费者模式：一方生产数据，另一方消费数据
  • 事件处理系统：处理高频率事件流
  • 游戏引擎：需要低延迟线程通信的游戏场景

4. 详细功能模块与代码示例

4.1 基本用法

 #include <boost/lockfree/queue.hpp>
 #include 
 
 int main()
 {
     // 创建一个容量为100的固定大小无锁队列
     boost::lockfree::queue queue(100);
     
     // 入队操作
     int value = 42;
     bool success = queue.push(value);
     if (success) {
         std::cout << "成功将 " << value << " 入队\n";
     } else {
         std::cout << "入队失败，队列可能已满\n";
     }
     
     // 出队操作
     int result;
     if (queue.pop(result)) {
         std::cout << "成功出队: " << result << "\n";
     } else {
         std::cout << "出队失败，队列可能为空\n";
     }
     
     return 0;
 }

4.2 固定大小与动态大小队列

 #include <boost/lockfree/queue.hpp>
 #include 
 
 int main()
 {
     // 固定大小队列 - 构造时指定容量
     boost::lockfree::queue fixed_queue(100);
     
     // 动态大小队列 - 使用模板参数指定
     boost::lockfree::queue<int, boost::lockfree::capacity<0>> dynamic_queue;
     
     // 或使用fixed_sized标志禁用动态大小
     boost::lockfree::queue<int, boost::lockfree::fixed_sized> another_dynamic_queue;
     
     // 检查队列是否为固定大小
     std::cout << "固定队列是固定大小: " << fixed_queue.is_lock_free() << std::endl;
     std::cout << "动态队列是固定大小: " << dynamic_queue.is_lock_free() << std::endl;
     
     return 0;
 }

值得注意的是，动态大小队列内部使用了节点分配器，可能导致在某些操作中发生内存分配，这可能影响实时性能。

4.3 多生产者多消费者模式

这是boost::lockfree::queue最常见的使用场景：

 #include <boost/lockfree/queue.hpp>
 #include 
 #include 
 #include 
 #include 
 
 boost::lockfree::queue queue(1000);
 std::atomic done(false);
 std::atomic produced_count(0);
 std::atomic consumed_count(0);
 
 void producer(int id)
 {
     for (int i = 0; i < 1000; ++i) {
         int value = id * 10000 + i;
         while (!queue.push(value)) {
             // 队列满时，让出CPU时间片
             std::this_thread::yield();
         }
         produced_count.fetch_add(1);
     }
 }
 
 void consumer()
 {
     int value;
     while (!done || !queue.empty()) {
         if (queue.pop(value)) {
             consumed_count.fetch_add(1);
             // 处理value，这里只是简单打印
             if (consumed_count % 1000 == 0) {
                 std::cout << "已消费: " << consumed_count << " 项\n";
             }
         } else {
             std::this_thread::yield();
         }
     }
 }
 
 int main()
 {
     // 创建生产者线程
     std::vector producers;
     for (int i = 0; i < 4; ++i) {
         producers.push_back(std::thread(producer, i));
     }
     
     // 创建消费者线程
     std::vector consumers;
     for (int i = 0; i < 2; ++i) {
         consumers.push_back(std::thread(consumer));
     }
     
     // 等待所有生产者完成
     for (auto& t : producers) {
         t.join();
     }
     
     // 通知消费者所有生产已完成
     done = true;
     
     // 等待所有消费者完成
     for (auto& t : consumers) {
         t.join();
     }
     
     std::cout << "生产项总数: " << produced_count << std::endl;
     std::cout << "消费项总数: " << consumed_count << std::endl;
     
     return 0;
 }

4.4 批量操作

boost::lockfree::queue提供了批量入队和出队操作，可以提高性能：

 #include <boost/lockfree/queue.hpp>
 #include 
 #include 
 
 int main()
 {
     boost::lockfree::queue queue(100);
     
     // 准备批量入队的数据
     std::vector items_to_push = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
     
     // 批量入队
     size_t pushed = queue.push(items_to_push.begin(), items_to_push.end());
     std::cout << "成功入队 " << pushed << " 个元素\n";
     
     // 批量出队
     std::vector results(10);
     size_t popped = queue.pop(results.begin(), results.end());
     
     std::cout << "成功出队 " << popped << " 个元素: ";
     for (size_t i = 0; i < popped; ++i) {
         std::cout << results[i] << " ";
     }
     std::cout << std::endl;
     
     return 0;
 }

4.5 消费者遍历

可以使用consume_one和consume_all函数结合回调函数处理队列中的元素：

 #include <boost/lockfree/queue.hpp>
 #include 
 #include 
 
 int main()
 {
     boost::lockfree::queue queue(100);
     
     // 添加一些元素
     for (int i = 0; i < 10; ++i) {
         queue.push(i);
     }
     
     // 使用consume_one处理单个元素
     bool consumed = queue.consume_one([](int value) {
         std::cout << "consume_one处理元素: " << value << std::endl;
     });
     
     std::cout << "consume_one " << (consumed ? "成功" : "失败") << std::endl;
     
     // 使用consume_all处理所有元素
     size_t consumed_count = queue.consume_all([](int value) {
         std::cout << "consume_all处理元素: " << value << std::endl;
     });
     
     std::cout << "consume_all处理了 " << consumed_count << " 个元素\n";
     
     return 0;
 }

4.6 队列容量与状态查询

boost::lockfree::queue提供了查询队列状态的方法：

 #include <boost/lockfree/queue.hpp>
 #include 
 
 int main()
 {
     boost::lockfree::queue queue(10);
     
     // 填充队列
     for (int i = 0; i < 5; ++i) {
         queue.push(i);
     }
     
     // 检查队列是否为空
     std::cout << "队列是否为空: " << (queue.empty() ? "是" : "否") << std::endl;
     
     // 获取队列当前大小（近似值）
     // 注意：在并发环境中这个值只是一个估计
     std::cout << "队列大小估计: " << queue.read_available() << std::endl;
     
     // 清空队列
     queue.consume_all([](int){});
     std::cout << "清空后队列是否为空: " << (queue.empty() ? "是" : "否") << std::endl;
     
     return 0;
 }

4.7 高级配置选项

boost::lockfree::queue提供了多种配置选项来满足不同需求：

 #include <boost/lockfree/queue.hpp>
 #include 
 #include <boost/pool/pool_alloc.hpp>
 
 // 自定义分配器
 typedef boost::fast_pool_allocator pool_allocator;
 
 int main()
 {
     // 使用自定义分配器的队列
     boost::lockfree::queue<int, boost::lockfree::allocator> custom_alloc_queue(100);
     
     // 配置固定大小
     boost::lockfree::queue<int, boost::lockfree::fixed_sized> fixed_queue(100);
     
     // 自定义内存对齐
     boost::lockfree::queue<int, boost::lockfree::alignment<16>> aligned_queue(100);
     
     // 组合多个选项
     boost::lockfree::queue<
         int,
         boost::lockfree::capacity<1000>,        // 固定容量
         boost::lockfree::fixed_sized,     // 固定大小
         boost::lockfree::allocator // 自定义分配器
     > advanced_queue;
     
     // 测试队列功能
     for (int i = 0; i < 10; ++i) {
         custom_alloc_queue.push(i);
         fixed_queue.push(i);
         aligned_queue.push(i);
         advanced_queue.push(i);
     }
     
     int value;
     while (custom_alloc_queue.pop(value)) {
         std::cout << "自定义分配器队列元素: " << value << std::endl;
     }
     
     return 0;
 }

4.8 性能优化与最佳实践

在使用boost::lockfree::queue时，以下最佳实践可以帮助您获得最佳性能：

#include <boost/lockfree/queue.hpp>
#include 
#include 
#include 
#include 
#include 

// 性能测试示例
void performance_test()
{
    // 使用合适的队列大小，避免频繁的内存分配
    constexpr size_t QUEUE_SIZE = 10000;
    boost::lockfree::queue<int, boost::lockfree::fixed_sized> queue(QUEUE_SIZE);
    
    std::atomic start{false};
    std::atomic ready_producers{0};
    std::atomic ready_consumers{0};
    std::atomic done{false};
    
    // 生产者
    auto producer = [&](int id, int items) {
        ready_producers++;
        while (!start.load(std::memory_order_acquire)) {
            std::this_thread::yield(); // 等待开始信号
        }
        
        for (int i = 0; i < items i int value='id' 1000000 i if i 100='= 0' i> 0) {
                std::vector batch;
                for (int j = 0; j < 100 j batch.push_backvalue - 100 j queue.pushbatch.begin batch.end else int retry='0;' while queue.pushvalue if retry> 10) {
                        std::this_thread::sleep_for(std::chrono::microseconds(1 << std::min(retry, 10)));
                    } else {
                        std::this_thread::yield();
                    }
                }
            }
        }
    };
    
    // 消费者
    auto consumer = [&]() {
        ready_consumers++;
        while (!start.load(std::memory_order_acquire)) {
            std::this_thread::yield(); // 等待开始信号
        }
        
        std::vector batch(100);
        int value;
        
        while (!done || !queue.empty()) {
            // 尝试批量出队
            size_t popped = queue.pop(batch.begin(), batch.end());
            if (popped > 0) {
                // 处理批量数据
                continue;
            }
            
            // 单个出队
            if (queue.pop(value)) {
                // 处理单个元素
            } else {
                // 智能退避，避免CPU空转
                std::this_thread::yield();
            }
        }
    };
    
    // 创建线程
    constexpr int NUM_PRODUCERS = 4;
    constexpr int NUM_CONSUMERS = 4;
    constexpr int ITEMS_PER_PRODUCER = 100000;
    
    std::vector producers;
    std::vector consumers;
    
    for (int i = 0; i < NUM_PRODUCERS; ++i) {
        producers.emplace_back(producer, i, ITEMS_PER_PRODUCER);
    }
    
    for (int i = 0; i < NUM_CONSUMERS; ++i) {
        consumers.emplace_back(consumer);
    }
    
    // 等待所有线程就绪
    while (ready_producers < NUM_PRODUCERS || ready_consumers < NUM_CONSUMERS) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    
    // 开始计时
    auto start_time = std::chrono::high_resolution_clock::now();
    
    // 发出开始信号
    start.store(true, std::memory_order_release);
    
    // 等待生产者完成
    for (auto& t : producers) {
        t.join();
    }
    
    // 标记生产者已完成
    done = true;
    
    // 等待消费者完成
    for (auto& t : consumers) {
        t.join();
    }
    
    auto end_time = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast(end_time - start_time);
    
    std::cout << "处理 " << NUM_PRODUCERS * ITEMS_PER_PRODUCER 
              << " 项数据耗时: " << duration.count() << " 毫秒" << std::endl;
    std::cout << "每秒处理约 " 
              << (NUM_PRODUCERS * ITEMS_PER_PRODUCER * 1000.0 / duration.count())
              << " 项" << std::endl;
}

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

4.9 与其他Boost组件结合使用

boost::lockfree::queue可以与其他Boost组件结合使用，实现更复杂的功能：

#include <boost/lockfree/queue.hpp>
#include <boost/asio.hpp>
#include <boost/bind/bind.hpp>
#include 
#include 
#include 

// 任务队列类示例
class TaskQueue {
private:
    boost::lockfree::queue<std::function*> task_queue{1000};
    boost::asio::io_context io_context;
    std::unique_ptr work;
    std::vector worker_threads;
    std::atomic running{false};
    
public:
    TaskQueue(int num_threads = 4) : work(std::make_unique(io_context)) {
        running = true;
        
        // 启动工作线程
        for (int i = 0; i < num_threads; ++i) {
            worker_threads.emplace_back([this]() {
                while (running) {
                    // 尝试从队列中获取任务
                    std::function* task = nullptr;
                    if (task_queue.pop(task)) {
                        if (task) {
                            // 执行任务
                            (*task)();
                            delete task;
                        }
                    } else {
                        // 没有任务时处理IO事件
                        io_context.poll_one();
                        std::this_thread::yield();
                    }
                }
            });
        }
    }
    
    ~TaskQueue() {
        stop();
    }
    
    // 提交任务
    template
    bool submit(F&& task) {
        auto* task_ptr = new std::function(std::forward(task));
        bool success = task_queue.push(task_ptr);
        if (!success) {
            delete task_ptr;
        }
        return success;
    }
    
    // 定时任务
    template
    void schedule_after(int milliseconds, F&& task) {
        auto timer = std::make_shared(io_context);
        timer->expires_after(std::chrono::milliseconds(milliseconds));
        timer->async_wait([timer, task = std::forward(task)](const boost::system::error_code& ec) {
            if (!ec) {
                task();
            }
        });
    }
    
    // 停止队列处理
    void stop() {
        if (running) {
            running = false;
            work.reset();
            io_context.stop();
            
            for (auto& thread : worker_threads) {
                if (thread.joinable()) {
                    thread.join();
                }
            }
            
            worker_threads.clear();
            
            // 清空剩余任务
            std::function* task = nullptr;
            while (task_queue.pop(task)) {
                delete task;
            }
        }
    }
};

// 使用示例
int main() {
    TaskQueue task_queue(4);
    
    // 提交普通任务
    for (int i = 0; i < 10; ++i) {
        task_queue.submit([i]() {
            std::cout << "执行任务 " << i << " 在线程 " 
                      << std::this_thread::get_id() << std::endl;
        });
    }
    
    // 提交延迟任务
    task_queue.schedule_after(1000, []() {
        std::cout << "1秒后执行的定时任务" << std::endl;
    });
    
    // 等待任务完成
    std::this_thread::sleep_for(std::chrono::seconds(2));
    
    return 0;
}

5. 注意事项与限制

使用boost::lockfree::queue时需要注意以下几点：

  1. 内存一致性：无锁队列依赖特定的内存序来保证正确性，不当使用可能导致难以发现的并发问题。
  2. 固定大小限制：固定大小队列可能会因队列满而拒绝新元素，必须有处理这种情况的策略。
  3. 动态内存分配：动态大小队列可能在运行时进行内存分配，这可能不适合对延迟敏感的应用程序。
  4. ABA问题：虽然boost::lockfree::queue内部处理了ABA问题，但了解这一问题有助于理解实现细节。
  5. 原子操作开销：无锁队列虽然避免了锁的开销，但原子操作本身也有一定代价，在低竞争环境下可能不如简单的锁实现快。
  6. 对齐要求：某些平台上的原子操作可能需要特定的内存对齐，boost::lockfree::queue会自动处理这些要求。

6. 总结

boost::lockfree::queue是一个强大的无锁队列实现，能够在多线程环境中提供高性能的数据交换。它无需使用互斥锁，因此避免了与锁相关的多种问题，特别适合对延迟敏感或高并发的应用场景。

相关推荐

VBA中利用Instr函数（vba int函数）

【分享成果，随喜正能量】每一个在你的生命里出现的人，都有原因，喜欢你的人给了你温暖和勇气，你喜欢的人让你学会了爱和自持，你不喜欢的人教会你宽容与尊重，不喜欢你的人让你自省与成长。。...

Insta360 Link体验:支持4K画质，一款使用场景丰富的AI云台摄像头

记者｜王公逸伴随直播、线上会议需求的兴起，网络直播的需求愈发增大，8月2日，影石Insta360正式推出全新产品：Insta360Link，这是一款AI智能云台摄像头。从产品形态来说，Insta3...

VBA技术资料MF299:利用Instr进行文本查找

我给VBA的定义：VBA是个人小型自动化处理的有效工具。利用好了，可以大大提高自己的工作效率，而且可以提高数据的准确度。“VBA语言専攻”提供的教程一共九套，分为初级、中级、高级三大部分，教程是对VB...

Fabric.js 拖放元素进画布 - 掘金

本文简介点赞+关注+收藏=学会了学习Fabric.js，我的建议是看文档不如看demo。本文实现的功能：将元素拖进到画布中并生成对应的图形或图片。效果如下图所示：...

Vue3为什么推荐使用ref而不是reactive

为什么推荐使用ref而不是reactivereactive本身具有很大局限性导致使用过程需要额外注意,如果忽视这些问题将对开发造成不小的麻烦;ref更像是vue2时代optionapi的data的替...

Fabric.js 样式不更新怎么办?（js更改样式）

本文简介带尬猴，我嗨德育处主任不知道你有没有遇到过在使用Fabric.js时无意中一些骚操作修改了元素的样式，但刷新画布却没更新元素样式？如果你也遇到同样的问题的话，可以尝试使用本文的方法。...

Fabric.js 修改画布交互方式到底有什么用?

本文简介点赞+关注+收藏=学会了fabric.js为我们提供了很多厉害的方法。今天要搞明白的一个东西是canvas.interactive。官方文档对canvas.interact...

Rust Web编程:第五章 在浏览器上显示内容

我们现在正处于可以构建一个Web应用程序的阶段，该应用程序可以使用不同的方法和数据管理一系列HTTP请求。这很有用，特别是当我们为微服务构建服务器时。然而，我们也希望非程序员能够与我们的应...

Fabric.js 自由绘制椭圆 - 掘金（canvas画椭圆）

本文简介点赞+关注+收藏=学会了本文讲解在Fabric.js中如何自由绘制椭圆形，如果你还不了解Fabric.js，可以查阅《Fabric.js从入门到精通》。效果如下图所示...

手把手教你实现JS手搓&quot;防抖&quot;优化代码——专业的事用专业的方法!

前言在我们前端编程中，假如我们要给后端发送请求，万一手抖多点了几次，多发送了几遍怎么办？解决方案：防抖！这种事就要交给我们专业的“防抖”先生来处理！今天，我们就来教大家手搓“防抖”...

详解虚拟DOM与Diff算法（虚拟dom一定比实际dom快吗）

vue的虚拟DOM,Diff算法，其中一些关键的地方从别处搬运了一些图进行说明(感谢制图的大佬)，也包含比较详细的源码解读。...

走进 React Fiber 的世界（我走进你的世界手势舞视频）

文/阿里淘系F(x)Team-冷卉Fiber设计思想Fiber是对React核心算法的重构，facebook团队使用两年多的时间去重构React的核心算法，在React16以上...

前端新一代框架 Svelte 火了!十个场景带你简单认识它!

近几年听到的主流框架都是Vue、React、Angular，但其实有一个框架在国外非常火，用起来也是很方便，那就是...

借助DeepSeek实现了一个PDF阅读器

1、简介使用pdf.js库加载和显示PDF文件。实现了翻页、缩放功能。提供了基本的错误处理。功能特点：支持选择本地PDF文件。可以逐页查看PDF内容。支持放大缩小功能。界面简洁，易于使...

DeepSeek代码之旅1:卫星地图标记方法之——html语言的实现

最近遇到一个任务，具体功能如下：1、调用高德地图API，图层为卫星图层，根据需要标记兴趣点；2、标记完成后可以保存兴趣点，便于下次加载历史兴趣点。...

取消回复欢迎 你 发表评论:

一周热门
最近发表
标签列表