C++线程池实现解析

已于 2022-10-22 03:14:09 修改
阅读量1.3k 收藏 11
点赞数 2
分类专栏： C++ 文章标签： c++ 开发语言
于 2022-10-22 03:13:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014552102/article/details/127438016
版权

一.简介

progschj/ThreadPool（链接：GitHub - progschj/ThreadPool: A simple C++11 Thread Pool implementation​​​​​​ ）是一个用到C++11特性的跨平台线程池，可以在windows，linux上运行。其只用不到100行代码就实现了线程池的基本功能，麻雀虽小五脏俱全，非常适合初学者学习。本文对其源码进行分析。

二.源码

ThreadPool.h

#ifndef THREAD_POOL_H
#define THREAD_POOL_H

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

class ThreadPool {
public:
    ThreadPool(size_t);
    template<class F, class... Args>
    auto enqueue(F&& f, Args&&... args) 
        -> std::future<typename std::result_of<F(Args...)>::type>;
    ~ThreadPool();
private:
    // need to keep track of threads so we can join them
    std::vector< std::thread > workers;
    // the task queue
    std::queue< std::function<void()> > tasks;
    
    // synchronization
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};
 
// the constructor just launches some amount of workers
inline ThreadPool::ThreadPool(size_t threads)
    :   stop(false)
{
    for(size_t i = 0;i<threads;++i)
        workers.emplace_back(
            [this]
            {
                for(;;)
                {
                    std::function<void()> task;

                    {
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock,
                            [this]{ return this->stop || !this->tasks.empty(); });
                        if(this->stop && this->tasks.empty())
                            return;
                        task = std::move(this->tasks.front());
                        this->tasks.pop();
                    }

                    task();
                }
            }
        );
}

// add new work item to the pool
template<class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args) 
    -> std::future<typename std::result_of<F(Args...)>::type>
{
    using return_type = typename std::result_of<F(Args...)>::type;

    auto task = std::make_shared< std::packaged_task<return_type()> >(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        
    std::future<return_type> res = task->get_future();
    {
        std::unique_lock<std::mutex> lock(queue_mutex);

        // don't allow enqueueing after stopping the pool
        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");

        tasks.emplace([task](){ (*task)(); });
    }
    condition.notify_one();
    return res;
}

// the destructor joins all threads
inline ThreadPool::~ThreadPool()
{
    {
        std::unique_lock<std::mutex> lock(queue_mutex);
        stop = true;
    }
    condition.notify_all();
    for(std::thread &worker: workers)
        worker.join();
}

#endif

使用例子：

example.cpp

#include <iostream>
#include <vector>
#include <chrono>

#include "ThreadPool.h"

int main()
{
    
    ThreadPool pool(4);
    std::vector< std::future<int> > results;

    for(int i = 0; i < 8; ++i) {
        results.emplace_back(
            pool.enqueue([i] {
                std::cout << "hello " << i << std::endl;
                std::this_thread::sleep_for(std::chrono::seconds(1));
                std::cout << "world " << i << std::endl;
                return i*i;
            })
        );
    }

    for(auto && result: results)
        std::cout << result.get() << ' ';
    std::cout << std::endl;
    
    return 0;
}

三.总流程分析

上述例子中通过ThreadPool pool(4)创建了4个工作线程，将任务

{
                std::cout << "hello " << i << std::endl;
                std::this_thread::sleep_for(std::chrono::seconds(1));
                std::cout << "world " << i << std::endl;
                return i*i;
}

添加到任务队列（ThreadPool的std::queue< std::function<void()> > tasks）中，然后在创建的子线程中启动这些任务。最后通过：

for(auto && result: results)
        std::cout << result.get() << ' ';
    std::cout << std::endl;

阻塞等待子线程执行完毕，打印任务的返回值（i*i的结果）。
 

四.源码分析

首先我们分析ThreadPool::enqueue函数

（1）

template<class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args) 
    -> std::future<typename std::result_of<F(Args...)>::type>

template<class F, class... Args>等价于template<typename F, typename... Args>，其中由于有参数class F，所以可以把lambda表达式或函数作为enqueue的第一个参数传进去。class... Args是可变长参数模板，负责把参数传到函数F里面。所以可以在example.cpp中实现：

pool.enqueue([i] {
    std::cout << "hello " << i << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "world " << i << std::endl;
    return i*i;
}

上述例子中

[i] {
    std::cout << "hello " << i << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "world " << i << std::endl;
    return i*i;
}

是lambda表达式，[i]是捕获列表，表示按值捕获i，所以大括号的代码中可以打印i的值

可以用函数替换掉lambda表达式作为参数传到enqueue里面，所以上述例子可以改写成：

#include <iostream>
#include <vector>
#include <chrono>

#include "ThreadPool.h"

int fun(int i)
{
    std::cout << "hello " << i << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "world " << i << std::endl;
    return i * i;
}

int main()
{

    ThreadPool pool(4);
    std::vector< std::future<int> > results;
    
    for (int i = 0; i < 8; ++i) {

        results.emplace_back(pool.enqueue(fun, i));
    }

    for(auto && result: results)
        std::cout << "get:" << result.get() << std::endl;
    //std::cout << std::endl;

    return 0;
}

这里面实参fun对应形参F&& f，实参i对应形参Args&&... args 。

（2）

template<class F, class... Args>
auto ThreadPool::enqueue(F&& f, Args&&... args) 
    -> std::future<typename std::result_of<F(Args...)>::type>

这里的“-> std::future<typename std::result_of<F(Args...)>::type>”是返回类型后置，和auto结合起来进行使用，共同完成函数返回值类型的推导，这里enqueue函数的返回值就是std::future<typename std::result_of<F(Args...)>::type>。

由于在example.cpp中

pool.enqueue([i] {
    std::cout << "hello " << i << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "world " << i << std::endl;
    return i*i;
}

std::result_of<F(Args...)为该lambda表达式的返回值(i*i）的类型，也就是int。所以这里enqueue函数的返回值为std::future<int>类型。在C++14中可省略箭头返回值部分，直接将函数返回类型设置为auto，所以enqueue函数可以去掉“-> std::future<typename std::result_of<F(Args...)>::type>”这部分直接写成：

auto ThreadPool::enqueue(F&& f, Args&&... args)

（3）

using return_type = typename std::result_of<F(Args...)>::type;

using用来给typename std::result_of<F(Args...)>::type取别名，相当于typedef

（4）

auto task = std::make_shared< std::packaged_task<return_type()> >(
            std::bind(std::forward<F>(f), std::forward<Args>(args)...)
        );
        
    std::future<return_type> res = task->get_future();

这里创建得到一个packaged_task对象，进而通过它的get_future()成员函数得到已经配对完成的future对象。随后，我们通过ThreadPool::ThreadPool中创建的子线程来执行这个packaged_task，也就是执行线程函数

{
    std::cout << "hello " << i << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "world " << i << std::endl;
    return i*i;
}

开始准备结果数据。与此同时，我们在main函数中使用future对象的get()函数

for(auto && result: results)
        std::cout << result.get() << ' ';
    std::cout << std::endl;

来等待分支线程执行完毕。一旦分支线程的线程函数执行完毕返回结果数据（return i*i)，result数据就会被主线程中的get()函数获得而返回。

(5)

 {
        std::unique_lock<std::mutex> lock(queue_mutex);

        // don't allow enqueueing after stopping the pool
        if(stop)
            throw std::runtime_error("enqueue on stopped ThreadPool");

        tasks.emplace([task](){ (*task)(); });
    }
    condition.notify_one();

std::queue< std::function<void()> > tasks是任务队列。std::function等价于函数指针，绑定{ (*task)(); }。这里将任务放到任务队列中，为了避免有多个线程同时对tasks进行操作，所以这里得加锁std::unique_lock<std::mutex> lock(queue_mutex)，保证在任一时刻，只能有一个线程访问它。然后通过condition.notify_one() 通知ThreadPool::ThreadPool中第一个进入阻塞或者等待的线程，取消对线程的阻塞。

我们接着分析inline ThreadPool::ThreadPool(size_t threads)函数

（6）

for(size_t i = 0;i<threads;++i)
        workers.emplace_back(
...

通过这里创建了threads个子线程

（7）

{
                        std::unique_lock<std::mutex> lock(this->queue_mutex);
                        this->condition.wait(lock,
                            [this]{ return this->stop || !this->tasks.empty(); });
                        if(this->stop && this->tasks.empty())
                            return;
.....

这里通过条件变量，让任务队列为空的时候可以阻塞，避免不断轮询判断缓冲区是否为空消耗CPU。

（8）

  task = std::move(this->tasks.front());
  this->tasks.pop();

这里把任务出队列。其用到了移动赋值，避免拷贝，提高了性能。

（9）

task();

这里相当于执行了[task](){ (*task)(); }。而(*task)()执行了主函数

{
    std::cout << "hello " << i << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "world " << i << std::endl;
    return i*i;
}

中的内容，从而实现了在子线程中执行任务

cuijiecheng2018
关注
  • 2
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++11 可变模版参数的妙用--泛化之美
hyl999的专栏
05-21 1454
原文地址：https://www.cnblogs.com/qicosmos/p/4325949.html 1概述 C++11的新特性--可变模版参数（variadictemplates）是C++11新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。相比C++98/03，类模版和函数模版中只能含固定数量的模版参数，可变模版参数无疑是一个巨大的改进。然而由于可变模版参数比较抽象，使用起来需要一定的技巧，所以它也是C++11中最难理解和掌握的特性之一。虽然掌握可变模版参数.
C++11：模板（可变模板参数）
you_fathe的博客
08-16 3460
介绍C++ 模板的用法和C++11新特性：可变参数模板
C++开源库ThreadPool源码解析
最新发布
HnIyM的博客
06-07 605
ThreadPool开源库仅用100行代码，运用许多C11特性实现多线程。本文将梳理自己阅读过程中的理解逐行进行解释，并且给出了所有可能疑问的对应答案。
基于C++11/14的线程池（可添加任意类型函数任务）
fhakfs的博客
04-28 1831
基于cpp14完成的线程池 线程池线程数量在构造对象时可指定。 线程池中包含一个deque的任务队列。 可通过外部接口像队列中增加任务。 当有空闲线程时便会处理任务队列中的任务。 析构或结束时回收线程资源。 ThreadPool.h文件 #pragma once #include <deque> #include <memory> #include <mutex> #include <functional> #include <con
简单的线程池实现
qq_39458250的博客
04-24 307
为了减少线程切换等操作所带来的开销，这里介绍一个简单的线程池的实现过程。 首先线程池主要由两个部分组成，分别是存放线程的容器和存放任务的队列。设计思路如下图流程图所示：线程池主要有两个执行函数。其中一个函数负责运行任务，也就是每个线程的运行实体，另一个函数负责放置任务到线程对应的队列。 线程池的定义如下：这里面thread_pool_vec是线程...
C++ 11 实现简单线程池
qq_40788199的博客
08-21 820
C++11使用新特性，实现最简单都线程池，详细注释
C++11封装线程池(2)
hyl999的专栏
05-21 1251
先上代码，代码来自GitHub。这段代码用了大量C++ 11新特性，并且非常晦涩难懂，接下来会对每个细节逐个解释。 ThreadPool.h #ifndef THREAD_POOL_H #define THREAD_POOL_H #include <vector> #include <queue> #include <memory> #include <thread> #include <mutex> #include <condit
C++线程池结合IOCP完成端口实现socket高并发服务端程序
02-22
"C++线程池结合IOCP完成端口实现socket高并发服务端程序"是一个利用现代C++特性，结合IO Completion Ports（IOCP）技术以及线程池策略来优化socket服务器性能的项目。IOCP是Windows操作系统中一种高效的I/O模型，...
c++简单线程池的实现
09-21
本文将深入探讨如何在Visual Studio 2015（VS2015）环境下实现一个简单的线程池，并解析提供的`TestThreadPool.sln`解决方案和`TestThreadPool`源代码文件。 线程池的基本思想是维护一组预先创建的线程，这些线程...
深入解析C++编程中线程池的使用
12-31
为什么需要线程池 目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器等都具有一个共同点，就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。 传 统多线程方案中我们采用的...
C++的网络线程池实现
05-05
下面是一个简单的C++线程池实现框架： ```cpp #include #include #include #include class ThreadPool { private: std::vector<std::thread> workers; std::queue()>> tasks; std::mutex queue_mutex; std...
C++11实现的一个线程池(ThreadPool)
Jesse_Liu666的博客
05-31 249
【代码】C++11实现的一个线程池(ThreadPool)
C++11 异步操作future和aysnc
kakaka666的博客
11-23 1107
C++11 异步操作future和aysnc
C++线程池简单实现
weixin_66448649的博客
06-30 5068
线程池: 当进行并行的任务作业操作时，线程的建立与销毁的开销是，阻碍性能进步的关键，因此线程池，由此产生。使用多个线程，无限制循环等待队列，进行计算和操作。帮助快速降低和减少性能损耗。 线程池的主要组成有上面三个部分：..................
C++11变参模板的参数包
zhouguoqionghai的博客
09-22 1万+
Parameter pack 原文来自这里 A template parameter pack is a template parameter that accepts zero or more template arguments (non-types, types, or templates). A function parameter pack is a function param
C++ \__VA_ARGS__ 在变参数模板类(Vardic template class) 中的使用
i07162056的博客
08-19 1079
C++ __VA_ARGS__ 在变参数模板类(Vardic template class) 中的使用 C++ 中 __VA_ARGS__ 宏的一个一般用法是实现可变参数的传递功能，例如 #define DEBUG_LOG(const char *fmt, ...) \ do { \ char dbgbuf[1024]; \ sprintf(dbgbuf, f...
C++多线程编程中std::future的使用
Passerby的博客
04-23 1万+
最近一直在搞多线程，C++的底子较烂，一开始直接用.detach()方法创建线程，但无法使输入顺序和输出顺序同步，而且输入数据在不断的产生，类似生产者和消费者问题，不断的创建新线程会浪费时间和资源，所以想到用线程池的方法。 std::future是一个类模板(class template)，其对象存储未来的值，一个std::future对象在内部存储一个将来会被赋值的值，并提供了一个访问该值的机...
c++11线程池实现
热门推荐
zdarks的专栏
07-22 4万+
咳咳。c++11 加入了线程库，从此告别了标准库不支持并发的历史。然而 c++ 对于多线程的支持还是比较低级，稍微高级一点的用法都需要自己去实现，譬如线程池、信号量等。线程池(thread pool)这个东西，在面试上多次被问到，一般的回答都是：“管理一个任务队列，一个线程队列，然后每次取一个任务分配给一个线程去做，循环往复。” 貌似没有问题吧。但是写起程序来的时候就出问题了。
C++实现线程池
蓬莱道人的博客
03-21 3万+
本文转载自：https://blog.csdn.net/caoshangpa/article/details/80374651 1、为什么需要线程池技术 目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器等都具有一个共同点，就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。传统多线程方案中我们采用的服务器模型则是一旦接受到请求之后，即创建一个新的线...
C++进阶重点知识精讲1-202110231
08-03
第一节课主要内容智能指针右值引用匿名函数正则表达式第二节课主要内容使用新特性实现线程池（支持可变参数列表）异常协程其他C++ 参考手册 https://zh.c

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值