TBB concurrent_queue

最新推荐文章于 2024-08-05 14:13:02 发布

ystraw_ah

最新推荐文章于 2024-08-05 14:13:02 发布

阅读量662

点赞数

分类专栏： c/c++ 文章标签： c++ 开发语言

本文链接：https://blog.youkuaiyun.com/qq_39451578/article/details/130957643

版权

c/c++ 专栏收录该内容

28 篇文章

订阅专栏

文章通过示例代码对比了TBB的concurrent_bounded_queue和标准库的std::queue在多线程环境下的使用，同时使用了一个自定义的线程池。测试中，两个队列都被用于数据处理，通过模拟延迟来观察它们的效率。结果显示，两者在特定测试环境下执行时间接近。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

参考：

#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <tbb/concurrent_queue.h>
#include <assert.h>
#include "../util/thread_pool.h"

ThreadPool worker_pool(1);
tbb::concurrent_bounded_queue<int> tbb_queue;
// tbb::concurrent_queue<int> tbb_queue;
std::queue<int> std_queue;
std::mutex queue_mux_;

/*----------------------------------TBB---------------------------------------*/

void tbb_f(int data) {
    // std::cout << " f : data " << data  << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(20)); // 模拟延迟
    tbb_queue.push(data);
}

void test_tbb() {
    tbb_queue.set_capacity(2);
    tbb_queue.push(1);
    tbb_queue.push(2);

    int data;
    tbb_queue.pop(data);

    for (int i = 0; i < 1000; i++) {
        // std::cout << "i=" << i << " deal with: data " << data  << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(20)); // 模拟延迟
        worker_pool.enqueue(tbb_f, data);
        tbb_queue.pop(data);
    }
}
/*----------------------------------------------------------------------------*/

static void Sleep(double t) {
  timespec req;
  req.tv_sec = (int) t;
  req.tv_nsec = (int64_t)(1e9 * (t - (int64_t) t));
  nanosleep(&req, NULL);
}

 
int get_data() {
    // Sleep(1.00001);
    while (true) {
        if (!std_queue.empty()) {
            std::unique_lock<std::mutex> lk(queue_mux_);
            auto data = std_queue.front();
            std_queue.pop();
            return data;
        }
        Sleep(0.0000001);
    }
}

void recycle_data(int data) {
    {
        std::unique_lock<std::mutex> lk(queue_mux_);
        std_queue.push(data);
    }
}

void std_f(int data) {
    // std::cout << " f : data " << data  << std::endl;
    std::this_thread::sleep_for(std::chrono::milliseconds(20)); // 模拟延迟
    recycle_data(data);
}

void test_std() {
    std_queue.push(1);
    std_queue.push(2);

    int data = get_data();

    for (int i = 0; i < 1000; i++) {
        // std::cout << "i=" << i << " deal with: data " << data  << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(20)); // 模拟延迟
        worker_pool.enqueue(std_f, data);
        data = get_data();
    }
}

int main() {
    // cmd: g++ test_concurrent_queue.cpp -lpthread -ltbb && ./a.out

    {
        double insert_time = clock();
        std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
        test_tbb();
        std::chrono::steady_clock::time_point t2 = std::chrono::steady_clock::now();
        std::chrono::duration<double> time_span = std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1);
        std::cout << "  test_tbb time: " 
                << time_span.count()
                << " sec" << std::endl;
    }

    {
        double insert_time = clock();
        std::chrono::steady_clock::time_point t1 = std::chrono::steady_clock::now();
        test_std();
        std::chrono::steady_clock::time_point t2 = std::chrono::steady_clock::now();
        std::chrono::duration<double> time_span = std::chrono::duration_cast<std::chrono::duration<double>>(t2 - t1);
        std::cout << "  test_std time: " 
                << time_span.count()
                << " sec" << std::endl;
    }

    return 0;
}

/*
output:
  test_tbb time: 20.086 sec
  test_std time: 20.0813 sec
~ThreadPool
*/