C++代码详解：线程池实现以及细节详解

最新推荐文章于 2024-10-02 14:50:41 发布
最新推荐文章于 2024-10-02 14:50:41 发布
阅读量480 收藏 2
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WORK_GAME_LINE/article/details/129771035
版权 
//!
//! C++代码详解: 线程池实现以及细节详解
//!
//! ===== 线程池简介 =====
//! 线程池是并发任务中比较关键的一环，如服务器等需要多线程并发的任务环境，
//!     通常情况下会先提前建立线程池以防止内存不足时建立子线程出现失败的情况，
//!     建立线程池不仅可以避免子线程启动失败，也减少了需要时再建立的启动时间，
//!     提高对任务处理的响应速度
//!
//! 该线程池的实现是借鉴github高人气项目ThreadPool的线程池实现，
//!     并对代码进行了一点修改，提高代码可读性
//! ===== 线程池简介 =====
//!
//!
//! ===== 实现概念 =====
//! 该线程池只提供了创建线程池、插入任务、释放线程池三个功能，是固定数量线程池，
//!     用vector容器装载thread线程类，queue队列容器对外部任务函数进行排队，
//!     mutex互斥量让多线程进入排队状态，condition_variable条件变量通知睡眠线程。
//!
//! 任务流程：
//!     当线程池创建时，所有的线程都会执行create_func函数，进入wait的休眠状态，
//!     当有任务加入时，外部函数会被打包成function类，
//!         然后将function类对象加入队列，并通知线程函数，
//!         线程函数从wait函数的休眠点被唤醒，然后从队列中取出被打包function对象的任务，并执行，
//!         到此外部函数已经被线程执行完毕
//!     当调用add_work函数时该函数会立刻返回，外部通过返回future对象获取任务返回值，
//!         future类的get函数会堵塞线程，等待任务函数被执行完毕，
//!         通常不建议主线程等待返回值，否则主线程依旧会堵塞，此时多线程无意义（注意get函数不能多次调用）
//!     当有线程池触发析构函数时，会等待所有的线程执行玩全部任务之后，退出线程函数，
//!         完成对线程池的释放
//! ===== 实现概念 =====
//!
//!
//! ===== 前置知识 =====
//! 函数未知的类型返回值：auto返回值
//!     例子：
//!         auto func_name() -> int
//!     此时func_name函数的返回类型是int，等价 int func_name()，
//!
//! 类型推导：result_of推导类
//!     例子：
//!         函数声明：int func_func() { return 0; }
//!         类型推导：result_of<func_name()>::type
//!     result_of会根据func_func的类型int推导到type上，
//!     此时result_of::type的推导结果就是int类型
//!
//! 完美转发：forward转发函数
//!     forward函数就是将保留了当前函数参数的左值或者右值，
//!     将这个参数的属性转发到下一个函数的参数中，保留其左右值属性
//!     左值、右值的概念不好理解，是函数参数传递时的参数属性，
//!     参数属性会影响到编译器对重载函数的优先级选择
//!
//! 参数打包：bind打包函数
//!     将函数地址与参数打包为function对象，用于未来的执行，
//!     执行时调用前提准备好的参数，无需再次传入参数
//!
//! 打包函数：packaged_task包装类
//!     用于打包bind函数将其转为future类，准备在将来获取返回值
//!
//! 创建工厂：make_shared创建函数
//!     用于创建shared_ptr智能指针的函数，传入等待构建对象的参数
//! ===== 前置知识 =====
//!
//!
//! ThreadPool项目链接 : https://github.com/progschj/ThreadPool
//!
//! 结束语：文章下方会附带一份可直接调用的头文件代码
//!
#include <iostream>
#include <vector>
#include <queue>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <functional>

using namespace std;

//===== vpool_th线程池 =====
class vpool_th
{
public:
    //创建线程池
    vpool_th(size_t number)
    {
        //准备一个循环函数--给线程池内的线程[等待任务/执行任务]
        auto create_func = [=](){
            while(true)
            {
                std::function<void()> task;
                {
                    std::unique_lock<std::mutex> lock(_mutex);              //独占锁--获取队列任务
                    while (_tasks.empty() && _run) { _cond.wait(lock); }    //假唤醒--退出且队列为空
                    if(_run == false && _tasks.empty()) { return; }         //等待队列任务完成并退出任务
                    task = std::move(_tasks.front()); _tasks.pop();         //取任务
                }
                task(); //执行从队列获取的任务函数
            }
        };
        for(size_t i = 0;i<number;i++) { _workers.emplace_back(create_func); }
    }

    //释放线程池
    ~vpool_th()
    {
        { std::unique_lock<std::mutex> lock(_mutex); _run = false; }    //这里锁的用处--add_work执行时不给释放
        _cond.notify_all();                                             //唤醒所有线程准备退出
        for(std::thread &worker: _workers) { worker.join(); }           //等待所有线程完成任务后释放
    }

    //加入任务函数
    //      typename std::result_of<Tfunc(Targs...)>::type -- 获取外部函数的返回值类型
    template<class Tfunc, class... Targs>
    auto add_work(Tfunc&& func, Targs&&... args)
        -> std::future<typename std::result_of<Tfunc(Targs...)>::type>
    {
        using ret_type = typename std::result_of<Tfunc(Targs...)>::type;                //任务函数的返回类型
        auto pack = std::bind(std::forward<Tfunc>(func), std::forward<Targs>(args)...); //任务函数打包
        auto task = std::make_shared<std::packaged_task<ret_type()>>(pack);             //打包为连接future类
        auto res = task->get_future();                                                  //从future类获取函数返回值
        {
            std::unique_lock<std::mutex> lock(_mutex);              //锁住并准备将任务插入队列
            std::function<void()> func = [task](){ (*task)(); };    //包装外部任务函数到function
            if(_run) { _tasks.emplace(func); }                      //插入function到队列
        }
        _cond.notify_one(); //通知一个线程去完成任务
        return res;
    }

private:
    bool _run = true;                           //运行标记
    std::vector<std::thread> _workers;          //线程容器
    std::mutex _mutex;                          //线程池锁
    std::queue<std::function<void()>> _tasks;   //任务队列
    std::condition_variable _cond;              //条件变量
};
//===== vpool_th线程池 =====


#include <windows.h>

int work(int i,int j)
{
    cout<<endl<<"th:"<<this_thread::get_id()<<endl;
    cout<<"ret:"<<i<<"+"<<j<<endl;
    return i+j;
}

void work_sleep(int time)
{
    cout<<endl<<"th:"<<this_thread::get_id()<<endl;
    cout<<"time:"<<time<<endl;
    Sleep(time);
}

class test_c
{
public:
    int work(int i,int j)
    {
        cout<<endl<<"th:"<<this_thread::get_id()<<endl;
        cout<<"ret:"<<i<<"+"<<j<<endl;
        return i+j;
    }

    void work_sleep(int time)
    {
        cout<<endl<<"th:"<<this_thread::get_id()<<endl;
        cout<<"time:"<<time<<endl;
        Sleep(time);
    }
};

void test()
{

    //===== 测试 =====
    cout << "== begin ==" << endl;
    future<int> fp;//外部获取返回值,销毁线程池后显示
    int sum = 0;

    //创建临时区
    {
        test_c t;
        vpool_th po(3);
        auto p1 = po.add_work(work,1,2);
        auto p2 = po.add_work(work,10,20);
        auto p3 = po.add_work(work_sleep,1);
        auto p4 = po.add_work(work_sleep,2);
        fp = po.add_work(&test_c::work,t,100,20);
        auto p5 = po.add_work(&test_c::work_sleep,t,1);

        //获取返回值
        int k1 = p1.get();
        int k2 = p2.get();

        cout<<"p:"<<k1<<"|"<<k2<<endl;
        sum += k1 + k2;
    }
    cout<<"sum:"<<sum<<endl;
    cout<<"fp:"<<fp.get()<<endl;

    //累加线程池的返回值
    cout << "== too work ==" << endl;
    vpool_th po(50);
    vector<future<int>> vec_sum;
    for(int i=0;i<10000;i++)
    {
        vec_sum.push_back(po.add_work(work,100,100));
    }

    int sum2 = 0;
    for(size_t i=0;i<vec_sum.size();i++)
    {
        sum2 += vec_sum[i].get();
    }
    cout<<"sum2: "<<sum2<<endl;
    cout << "== end ==" << endl;
    //===== 测试 =====
}

int m_main()
{
    cout<<"== begin =="<<endl;

    test();

    cout<<"== end =="<<endl;
    return 0;
}

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


#ifndef VPOOL_TH_H
#define VPOOL_TH_H

#include <vector>
#include <queue>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <functional>

class vpool_th
{
public:
    //创建线程池
    vpool_th(size_t number)
    {
        //准备一个循环函数--给线程池内的线程[等待任务/执行任务]
        auto create_func = [=](){
            while(true)
            {
                std::function<void()> task;
                {
                    std::unique_lock<std::mutex> lock(_mutex);              //独占锁--获取队列任务
                    while (_tasks.empty() && _run) { _cond.wait(lock); }    //假唤醒--退出且队列为空
                    if(_run == false && _tasks.empty()) { return; }         //等待队列任务完成并退出任务
                    task = std::move(_tasks.front()); _tasks.pop();         //取任务
                }
                task(); //执行从队列获取的任务函数
            }
        };
        for(size_t i = 0;i<number;i++) { _workers.emplace_back(create_func); }
    }

    //释放线程池
    ~vpool_th()
    {
        { std::unique_lock<std::mutex> lock(_mutex); _run = false; }    //这里锁的用处--add_work执行时不给释放
        _cond.notify_all();                                             //唤醒所有线程准备退出
        for(std::thread &worker: _workers) { worker.join(); }           //等待所有线程完成任务后释放
    }

    //加入任务函数
    //      typename std::result_of<Tfunc(Targs...)>::type -- 获取外部函数的返回值类型
    template<class Tfunc, class... Targs>
    auto add_work(Tfunc&& func, Targs&&... args)
        -> std::future<typename std::result_of<Tfunc(Targs...)>::type>
    {
        using ret_type = typename std::result_of<Tfunc(Targs...)>::type;                //任务函数的返回类型
        auto pack = std::bind(std::forward<Tfunc>(func), std::forward<Targs>(args)...); //任务函数打包
        auto task = std::make_shared<std::packaged_task<ret_type()>>(pack);             //打包为连接future类
        auto res = task->get_future();                                                  //从future类获取函数返回值
        {
            std::unique_lock<std::mutex> lock(_mutex);              //锁住并准备将任务插入队列
            std::function<void()> func = [task](){ (*task)(); };    //包装外部任务函数到function
            if(_run) { _tasks.emplace(func); }                      //插入function到队列
        }
        _cond.notify_one(); //通知一个线程去完成任务
        return res;
    }

private:
    bool _run = true;                           //运行标记
    std::vector<std::thread> _workers;          //线程容器
    std::mutex _mutex;                          //线程池锁
    std::queue<std::function<void()>> _tasks;   //任务队列
    std::condition_variable _cond;              //条件变量
};

#endif // VPOOL_TH_H

HellowAmy
关注
C++实现Windows平台下的线程池
CodeLancerX的博客
08-10 330
线程池类的核心是run()函数，该函数用于运行每个子线程，并通过wait()和notify_one()等函数进行线程同步和互斥控制。线程池是一种常见的并发编程技术，它通过预先创建一定数量的线程，并管理它们的数量和状态来提高程序的性能和效率。在上述代码中，我们创建了一个线程池实例，并通过submit()函数将一组具体的业务逻辑任务（计算素数）提交到线程池中进行异步执行。接着，我们需要实现一个线程池类，该类用于管理线程池的数量和状态，并接受和执行任务。最后，我们可以使用线程池类来执行具体的业务逻辑任务。
C++实现线程池详解（基于boost源码以及封装等线程池）
10-15
三、简单的C++线程池代码示例 四、 基于boost编写的源码库 - 线程池 4.1 基于boost编写的源码库地址 4.2 boost线程池的先进先出、后进先出、优先级代码示例 五、看看人家线程池怎么写的 - 要理解精髓 六、线程池应用...
转载一份C++线程池的代码，非常实用
热门推荐
revv的专栏
11-07 3万+
#ifndef _ThreadPool_H_#define _ThreadPool_H_#pragma warning(disable: 4530)#pragma warning(disable: 4786)#include #include #include #include using namespace std;class ThreadJob  //工作基类{public:  //供线程池调
c++线程池代码
最新发布
2301_81341105的博客
10-02 276
【代码】c++线程池代码。
转载一份C++线程池的代码，非常实用(转)
gxj1680的专栏
08-28 885
#ifndef _ThreadPool_H_#define _ThreadPool_H_#pragma warning(disable: 4530)#pragma warning(disable: 4786)#include #include #include #include using namespace std;class ThreadJob  //工作基类{public:  //供
c++实现的线程池代码
qq_38158479的博客
01-14 439
#ifndef _THREADPOOL_H #define _THREADPOOL_H #include <vector> #include <queue> #include <thread> #include <iostream> #include <condition_variable> using namespace std; template <typename T> class threadPool { public:
一个Windows下线程池的实现（C++）
weixin_34014277的博客
02-19 175
前言 　　本文配套代码：https://github.com/TTGuoying/ThreadPool 　　先看看几个概念： 线程：进程中负责执行的执行单元。一个进程中至少有一个线程。 多线程：一个进程中有多个线程同时运行，根据cpu切换轮流工作，在多核cpu上可以几个线程同时在不同的核心上同时运行。 线程池：基本思想还是一种对象池思想，开辟一块内存空间，里面存放一些休眠（挂起...
C++并发编程：线程池详解与实践
在《简单的线程池 - 系统可靠性理论 - 模型统计方法及应用》一书中，章节9.1...通过这些内容，读者可以学习到如何利用线程池来提升程序性能，理解并发编程中的关键概念，以及如何设计和实现高效、可维护的并发代码。
C++多线程编程：线程池实例详解
上述知识点围绕C++多线程编程、线程池的设计与实现、使用示例、性能优化和常见问题等进行了详细的介绍。通过掌握这些知识点，开发者能够更好地理解和应用C++中的线程池技术，从而提升多线程应用的性能和可靠性。
"C++ 11多线程进阶：线程池实现与异常协程详解
总之，本节课中我们学习了使用C++11中的新特性来实现线程池，包括支持可变参数列表、异常处理和协程等功能。通过掌握这些知识，我们可以更好地控制并发和多线程环境下的问题，提高程序的性能和可靠性。为了深入了解...
C++中的std::async()详解
01-19
1、std::async函数原型： template future<typename>::type> async(launch policy, Fn&& fn, Args&&...args); 功能：第二个参数接收一个可调用对象（仿函数、lambda表达式、类成员函数、普通函数……）作为参数,...
c++线程池类代码实现
03-20
c++线程池类以及线程类代码实现，对于初学者来说是个很好的例子。
C++线程池源代码
12-10
无锁线程池源代码（原创）； 本线程池不使用锁，原子操作等内核函数。
Windows下线程池的实现（C++）
05-16
windows下threadpool的实现 ( C++ ) 1. Task对于参数的变化参考了loki的typelist的做法，可支持0 - 9个参数的函数对象。 2. task.h使用脚本自动生成（taskGen.py） 3. scheduler.h用于解耦thread_pool和task_thread两个模块。 main.cpp演示了tp_lib的使用方法，其中TaskMgr用于统一管理任务对象，并粘合thread_pool
C/C++(基于windows)超简单的线程池
09-02
1. 很适合新手学习线程池 2. 没有加锁, 大家要用的话自己加锁 3. 真的超简单, 代码量超少 4. 线程类是接口, 要自己继承才能使用, 里面有例子 5. 如果想加入 "插队" 线程机制, 可以把 STL的quene 换成 list, map等.
C++实现线程池
923723914
06-04 452
C++实现线程池。 欢迎转载，转载请注明原出处：http://blog.csdn.net/ithzhang/article/details/9020283 代码地址：https://github.com/ithzhang/ThreadpoolLib.git 本文介绍的线程池采用C++语言，在windows平台下实现。此版本为Version1.0，以后还...
一个Windows C++的线程池的实现
weixin_34228617的博客
09-18 137
此线程池所依赖的线程类，请参看《一个Windows C++的线程类实现》： http://blog.csdn.net/huyiyang2010/archive/2010/08/10/5801597.aspx   ThreadPoolExecutor.h [cpp] view plaincopy #ifndef __THREAD_POOL_EXECUTOR__  #def...
Windows C++ 线程池
yuguanquan1990的专栏
11-01 1709
Windows 本身提供的线程池解决
借助 C++ 进行 Windows 开发线程池环境
weixin_30254435的博客
10-03 130
组成 Windows 线程池 API 的对象可被分为两大阵营。第一阵营中的是那些表示工作、计时器、I/O 和可等待的对象。这些对象都有可能导致在线程池上执行回调。我已经在上个月的专栏中介绍过工作对象，并将在后续文章中探讨余下的对象。第二阵营中的是那些用来控制这些回调的执行环境的对象。这正是本月专栏的重点讨论内容。 线程池环境会影响回调是在默认池中执行，还是在您自己生成的特定池中执行，以及回调是否...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值