基于任务组的线程池（SequentialThreadPool）

已于 2024-08-05 11:47:41 修改
阅读量254 收藏 4
点赞数 5
文章标签： c++
于 2024-08-02 18:14:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kpengk/article/details/140876878
版权

一、背景

考虑有多个任务，比如有5个数据采集设备，需要对每个设备采集的数据进行处理，单个设备的数据需要按照数据产生的顺序进行处理，每个设备产生的频率不一致。应该如何处理上述需求？

  • 方案一：
    多线程处理：对每个设备采用一个线程进行处理，确保了设备的数据顺序。
    弊端：当设备增加时，浪费了大量线程；对于频率低的设备线程利用率低，对于频率高的设备处理能力可能不足。
  • 方案二：
    线程池处理：虽然能很好的利用资源，但无法保证单个设备的数据有序性。
  • 方案三：
    协程：协程能较好的处理此问题，但需要C++20支持，且无栈协程具有传染性。

基于上述情况，提出了一种按照任务组进行顺序执行的线程池。

二、简介

基于C++11实现的一个head-only的线程池。其区别于普通线程池在于：可以对任务进行分组，同一个组内的任务按照入队顺序进行执行，不同组之间的任务抢占式执行。线程资源平衡利用，避免出现某个线程利用率高，某个线程利用率低的问题。

三、实现原理

将任务分组放入对应任务组队列，每次从其中一个任务队列中取走一个任务，此时任务当前任务组处于锁定，当此任务完成后此任务组解锁，可再次取走任务进行执行。详细步骤图解如下：

  1. 添加任务时，将任务按照指定的组放入相应队列。如下图所示，将任务放入ABC三个任务组，同时将ABC三个组加入可运行任务组队列。（可运行任务组队列表示当前处于可运行状态的任务分组）。
    在这里插入图片描述
  2. 从可运行任务组队列中取出可执行的任务组标识，并从对应任务组取走任务进行执行。下图中取走A1和B1任务进行执行，此时任务组A和任务组B处于不可继续取任务状态。（两个线程同时运行任务，故取走了两个任务）。
    在这里插入图片描述
  3. 任务B1完成执行后，此时任务组B又处于可运行状态，将任务组B加入可运行任务组队列。
    在这里插入图片描述
  4. 此时只有一个任务处于运行状态，故根据可运行任务组中的指示取走任务组C中的一个任务C1进行执行。
    在这里插入图片描述
  5. 循环执行以上步骤，即可实现任务分组有序执行。

四、源码

核心源码

  1. 添加任务
void enqueue(int group, std::function<void()> task) {
    bool waiting{};
    {
        std::lock_guard<std::mutex> lock(mutex_);
        waiting = group_tasks_[group].empty(); // 任务组为空，说明此任务组没有任务正在执行
        group_tasks_[group].emplace(std::move(task)); // 将任务放入相应组
        if (waiting)
            runnable_group_.push(group); // 将任务组ID加入可运行任务组队列
    }
    if (waiting)
        condition_.notify_one();
}
  1. 执行任务
void run() {
    while (stop_token_) {
        uint32_t group{};
        std::function<void()> task{};
        // 根据可运行任务组队列取走任务
        {
            std::unique_lock<std::mutex> lock(mutex_);
            if (!condition_.wait_for(lock, std::chrono::seconds(1), [this]() { return !runnable_group_.empty(); })) {
               continue;
            }
            group = runnable_group_.front(); // 当前可运行的任务组ID
            runnable_group_.pop();
            task = std::move(group_tasks_[group].front()); // 从对应任务组中取走任务
        }
        // 执行任务
        task();

        bool notify{};
        {
            std::lock_guard<std::mutex> lock(mutex_);
            group_tasks_[group].pop();
            // 将当前任务组ID加入可运行任务组队列
            if (!group_tasks_[group].empty()) {
                runnable_group_.push(group);
                notify = true;
            }
        }
        if (notify)
            condition_.notify_one();
    }
}

最新源码见Github： SequentialThreadPool

五、使用

5.1 示例代码

#include "SequentialThreadPool.hpp"
#include <iostream>
#include <sstream>

int main() {
    const auto start = std::chrono::high_resolution_clock::now();

    SequentialThreadPool pool(4);
    for (int task = 0; task < 30; ++task) {
        const int group = task % 5; // Task Grouping
        pool.enqueue(group, [=]() {
            const auto end = std::chrono::high_resolution_clock::now();
            const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
            const int sleep = task == 0 ? 200 : rand() % 100 + 50;
            std::stringstream ss;
            ss << "Time:" << duration << ", group:" << group << ", task:" << task
               << ", tid:" << std::this_thread::get_id() << ", sleep:" << sleep << "ms\n";
            std::cout << ss.str();
            std::this_thread::sleep_for(std::chrono::milliseconds(sleep));
        });
    }

    return 0;
}

5.2 示例输出

Time:5,   group:0, task:0,  tid:23788, sleep:200ms
Time:5,   group:1, task:1,  tid:26944, sleep:91ms
Time:5,   group:2, task:2,  tid:27324, sleep:91ms
Time:5,   group:3, task:3,  tid:21836, sleep:91ms
Time:105, group:4, task:4,  tid:27324, sleep:117ms
Time:105, group:3, task:8,  tid:26944, sleep:117ms
Time:105, group:2, task:7,  tid:21836, sleep:117ms
Time:216, group:1, task:6,  tid:23788, sleep:91ms
Time:231, group:0, task:5,  tid:27324, sleep:84ms
Time:231, group:3, task:13, tid:26944, sleep:84ms
Time:231, group:2, task:12, tid:21836, sleep:84ms
Time:324, group:4, task:9,  tid:21836, sleep:50ms
Time:324, group:2, task:17, tid:23788, sleep:117ms
Time:324, group:1, task:11, tid:27324, sleep:50ms
Time:324, group:0, task:10, tid:26944, sleep:50ms
Time:386, group:0, task:15, tid:27324, sleep:119ms
Time:386, group:4, task:14, tid:21836, sleep:119ms
Time:386, group:3, task:18, tid:26944, sleep:119ms
Time:449, group:1, task:16, tid:23788, sleep:84ms
Time:513, group:0, task:20, tid:26944, sleep:74ms
Time:513, group:3, task:23, tid:21836, sleep:74ms
Time:513, group:2, task:22, tid:27324, sleep:74ms
Time:543, group:4, task:19, tid:23788, sleep:50ms
Time:589, group:1, task:21, tid:21836, sleep:128ms
Time:589, group:3, task:28, tid:27324, sleep:128ms
Time:589, group:2, task:27, tid:26944, sleep:128ms
Time:605, group:0, task:25, tid:23788, sleep:119ms
Time:728, group:1, task:26, tid:23788, sleep:74ms
Time:728, group:4, task:24, tid:21836, sleep:108ms
Time:838, group:4, task:29, tid:21836, sleep:112ms

5.3 示例任务执行顺序图

基于上述执行进行进行图形化后如下，组内任务顺序执行，组间任务并行执行。
在这里插入图片描述

墨尘笔尖
关注
  • 5
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ STL copy_backward, move_backward 用法
08-04 239
此处需要解释一下：从后向前并不是逆序，它的意思是: 源容器和目标容器都从尾部开始，然后向前迭代，执行拷贝/移动操作。反向（从后向前的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
C++ - 函数重载
jiaowenjie的专栏
08-06 195
/打印的是第二个函数的地址。//打印的是第一个函数的地址。-> 重载函数在本质上是相互独立的不同函数。-> 函数返回值不能作为函数重载的依据。-> 重载函数的函数类型不同。**3.函数默认参数和函数重载****函数重载的注意事项：****4.函数重载的本质**
C++ STL专题 list的讲解
Mike的博客
08-07 489
1.list是可以在常数范围内任意位置进行插入和删除的序列式容器，并且可以前后双向迭代。2. list的底层是双链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向其前一个元素和后一个元素。3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代。4. 与其他的序列式容器相比(vector，deque), list通常在任意位置进行插入，移除元素的执行效率更好。5. 与其他序列式容器相比，
伐木工 (100%用例)D卷 (Java&&Python&&C++&&Node.js&&C语言)
荆赫同艺的博客
08-07 35
一根 4米长的树木，伐木工不需要切割为 2*2，省去切割成本，直接整根树木交易，为 4*1，收益最大为 4。方式二: 3,2,2,3，但方式二，伐木工多切割一次，增加了切割成本却卖了一样的价格，因此并不是最优收益。一根 2 米长的树木，伐木工不切割，为2*1，收益最大为 2。一根5 米长的树木，伐木工切割为 2*3,收益最大为 6。输出最优收益时的各个树木长度，以空格分隔，按升序排列。一根 10 米长的树木，伐木工可以切割。方式一:3,4,4，也可以切割为。
C++ STL copy, move 用法
08-04 250
前向（从前向后的顺序）拷贝/移动操作，将一个容器元素拷贝/移动到另一容器中。
【C++】输入输出
2401_83948390的博客
08-02 585
在C++中，输入输出操作主要通过标准库中的iostream头文件提供的一系列对象和函数来完成。
C++ 继承 派生类的拷贝构造
gopher9511的博客
08-04 557
拷贝构造，也是一种构造函数，也没有被继承下来。
理解栈（Stack）及其在 C++ 中的应用【栈、数据结构】
qq_22841387的博客
08-07 240
栈是一种数据结构，它遵循“后进先出”（LIFO - Last In, First Out）的原则。栈就像是一叠盘子，你只能从最上面拿盘子，也只能在最上面放盘子。栈的这一特性使其在很多场景中非常有用，例如递归、回溯算法和表达式计算等。通过这篇博客，我们详细介绍了栈的基本概念及其在 C++ 中的实现。栈是一种非常有用的数据结构，尤其在处理递归、回溯和表达式计算等问题时。我们还讨论了如何将栈中的字符转换为字符串，以及如何使用栈解决括号匹配问题。
C++｜设计模式（八）｜⭐️工厂模式？错！是工厂模式群！
糖炒栗子
08-02 941
首先我们按照与 Employee 类相同的方式来创建所有不同项目对应的基类（父类）Project，在这个类中我们还定义了与项目相关的接口 assignTo ，这个接口可以将某个项目指派给对应账户ID的员工，还是相同的方式我们定义 ITProject 与 UIProject 这两个不同项目的子类，并提供 assignTo 接口的不同实现。
C++ SQL ORM
最新发布
一个大佬的博客
08-07 268
【代码】C++ SQL ORM。
string类的模拟实现(C++)
2302_80190394的博客
08-02 1148
C++ string的功能函数实现
在 Python 和 C++ 环境下安装和使用 ONNX Runtime
CDBmax的博客
08-03 356
对于 GPU 版本的 ONNX Runtime，需要安装 CUDA 和 cuDNN。请检查 CUDA 执行提供程序的要求以获取兼容版本的 CUDA 和 cuDNN。通过上述步骤和示例代码，您可以在 Python 和 C++ 环境下安装并使用 ONNX Runtime 进行模型推理。《windows端可以用 vs编辑器配置相应的头文件、库文件》《这部分可以去B站有很多教学视频讲的更详细》
C++ primer plus 第17 章 输入、输出和文件：使用 cin 进行输入
zhyjhacker的博客
08-05 1131
C++ primer plus 第17 章 输入、输出和文件：使用 cin 进行输入。
C++标准模板（STL）- 低层内存管理 - 分配函数（operator new, operator new[]）
qq_40788199的博客
08-02 1227
分配请求数量的字节。这些分配函数为 new 表达式所调用，以分配将被初始化的对象所在的内存。亦可用常规函数调用语法调用它们。
gcc: string.c_str gcc-8.5的一个问题
mzhan017的博客
08-04 80
string的这个成员是返回c类型的一个字符数组指针。但是这个指针所对应的地址有赖于string对象的生命周期。所以如果返回一个函数内的局部string对象的指针，就是危险的。如果是危险的有没有静态代码检查工具可用帮助来检查这种书写的问题。这里需要注意的一个问题是在gcc的4.8版本是可用隐藏这个问题，但是到了8.5这个版本，就不再隐藏了。所以对生命周期比较长的c++工程来说，这是一个非常大的挑战。因为原来这么错误使用也没有问题，那得有多少处这种错误使用呢？
【LeetCode Cookbook（C++ 描述）】一刷哈希表（Hash Table）（下）
David Max 的博客
08-02 970
本系列文章仅是 GitHub 大神 @halfrost 的刷题笔记《LeetCode Cookbook》的提纲以及示例、题集的 C++转化。原书请自行下载学习。本篇文章涉及新手应该优先刷的几道经典哈希表算法题，分两篇文章，以后会更新“二刷”“三刷”等等。
C++ | Leetcode C++题解之第324题摆动排序II
Ddddddd_158的博客
08-06 394
C++ | Leetcode C++题解之第324题摆动排序II
C语言 | Leetcode C语言题解之第326题3的幂
m0_59237910的博客
08-06 379
C语言 | Leetcode C语言题解之第326题3的幂
第七章 - c语言中的指针
百知_zmj的博客
08-02 241
指针的定义：数据类型 *指针变量名 [= 初始值 ];// 初始值可以省略。变量是存放数据的内存单元，变量的地址就是指针，而且不同类型的变量有不同类型的指针。指针：是内存单元的地址，使用指针可以更灵活访问内存单元中的数据。
基于libevent的线程池
05-24
libevent是一个事件驱动的网络编程库，它提供了高效的事件处理机制，可以在多种操作系统平台上运行。为了更好地利用libevent提供的优势，我们可以使用线程池来管理多个并发请求。 下面是一个基于libevent的简单线程池实现： ```c #include <event2/event.h> #include <event2/thread.h> #include <pthread.h> #define THREAD_POOL_SIZE 4 struct thread_pool { pthread_t threads[THREAD_POOL_SIZE]; struct event_base *base; }; void* thread_func(void *arg) { struct event_base *base = (struct event_base*)arg; event_base_dispatch(base); return NULL; } struct thread_pool* thread_pool_new() { struct thread_pool *pool = malloc(sizeof(struct thread_pool)); pool->base = event_base_new(); // Initialize libevent thread support evthread_use_pthreads(); // Create worker threads for (int i = 0; i < THREAD_POOL_SIZE; i++) { pthread_create(&pool->threads[i], NULL, thread_func, pool->base); } return pool; } void thread_pool_destroy(struct thread_pool *pool) { // Stop the event loop on all threads event_base_loopexit(pool->base, NULL); // Wait for all threads to exit for (int i = 0; i < THREAD_POOL_SIZE; i++) { pthread_join(pool->threads[i], NULL); } // Free the event base and the pool itself event_base_free(pool->base); free(pool); } void thread_pool_dispatch(struct thread_pool *pool, struct event *ev) { event_base_priority_init(pool->base, 2); event_base_set(pool->base, ev); event_add(ev, NULL); } ``` 这个线程池使用libevent提供的事件循环机制来处理多个并发请求。它启动了一个包含多个线程的事件循环，每个线程都可以处理事件。当一个事件需要处理时，线程池会将该事件加入到事件队列中，由空闲的线程来处理。 线程池的使用非常简单，只需要创建一个线程池对象，然后通过调用`thread_pool_dispatch`函数来将需要处理的事件加入到事件队列中即可。当不再需要使用线程池时，只需要调用`thread_pool_destroy`函数来释放线程池对象和相关资源。 需要注意的是，这个线程池的实现是比较简单的，适用于处理轻量级的请求。如果需要处理更加复杂的请求，可能需要进行更多的优化和调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值