练手：实现一个C++线程池

最新推荐文章于 2024-07-22 09:38:37 发布
最新推荐文章于 2024-07-22 09:38:37 发布
阅读量55 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/axyw_/article/details/133311940
版权

之前学习了：可变参数；std::future；packaged_task;bind等C++11特性，下面用这些重点知识等实现一个C++线程池。
这部分代码如果无法理解，可以参考往期的博文。
在这里插入图片描述

zero_threadpool.h

//zero_threadpool.h
#ifndef ZERO_THREADPOOL_H
#define ZERO_THREADPOOL_H

#include <future>
#include <functional>
#include <iostream>
#include <queue>
#include <mutex>
#include <memory>
#ifdef WIN32
#include <windows.h>
#else
#include <sys/time.h>
#endif
using namespace std;



void getNow(timeval *tv);
int64_t getNowMs();

#define TNOW      getNow()
#define TNOWMS    getNowMs()

/
/**
 * @file zero_thread_pool.h
 * @brief 线程池类,采用c++11来实现了，
 * 使用说明:
 * ZERO_ThreadPool tpool;
 * tpool.init(5);   //初始化线程池线程数
 * //启动线程方式
 * tpool.start();
 * //将任务丢到线程池中
 * tpool.exec(testFunction, 10);    //参数和start相同
 * //等待线程池结束
 * tpool.waitForAllDone(1000);      //参数<0时, 表示无限等待(注意有人调用stop也会推出)
 * //此时: 外部需要结束线程池是调用
 * tpool.stop();
 * 注意:
 * ZERO_ThreadPool::exec执行任务返回的是个future, 因此可以通过future异步获取结果, 比如:
 * int testInt(int i)
 * {
 *     return i;
 * }
 * auto f = tpool.exec(testInt, 5);
 * cout << f.get() << endl;   //当testInt在线程池中执行后, f.get()会返回数值5
 *
 * class Test
 * {
 * public:
 *     int test(int i);
 * };
 * Test t;
 * auto f = tpool.exec(std::bind(&Test::test, &t, std::placeholders::_1), 10);
 * //返回的future对象, 可以检查是否执行
 * cout << f.get() << endl;
 */

class ZERO_ThreadPool
{
protected:
    struct TaskFunc
    {
        TaskFunc(uint64_t expireTime) : _expireTime(expireTime)
        { }

        std::function<void()>   _func;
        int64_t                _expireTime = 0;	//超时的绝对时间
    };
    typedef shared_ptr<TaskFunc> TaskFuncPtr;
public:
    /**
    * @brief 构造函数
    *
    */
    ZERO_ThreadPool();

    /**
    * @brief 析构, 会停止所有线程
    */
    virtual ~ZERO_ThreadPool();

    /**
    * @brief 初始化.
    *
    * @param num 工作线程个数
    */
    bool init(size_t num);

    /**
    * @brief 获取线程个数.
    *
    * @return size_t 线程个数
    */
    size_t getThreadNum()
    {
        std::unique_lock<std::mutex> lock(mutex_);

        return threads_.size();
    }

    /**
    * @brief 获取当前线程池的任务数
    *
    * @return size_t 线程池的任务数
    */
    size_t getJobNum()
    {
        std::unique_lock<std::mutex> lock(mutex_);
        return tasks_.size();
    }

    /**
    * @brief 停止所有线程, 会等待所有线程结束
    */
    void stop();

    /**
    * @brief 启动所有线程
    */
    bool start(); // 创建线程

    /**
    * @brief 用线程池启用任务(F是function, Args是参数)
    *
    * @param ParentFunctor
    * @param tf
    * @return 返回任务的future对象, 可以通过这个对象来获取返回值
    */
    template <class F, class... Args>
    auto exec(F&& f, Args&&... args) -> std::future<decltype(f(args...))>
    {
        return exec(0,f,args...);
    }

    /**
    * @brief 用线程池启用任务(F是function, Args是参数)
    *
    * @param 超时时间 ，单位ms (为0时不做超时控制) ；若任务超时，此任务将被丢弃
    * @param bind function
    * @return 返回任务的future对象, 可以通过这个对象来获取返回值
    */
    /*
    template <class F, class... Args>
    它是c++里新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数
    auto exec(F &&f, Args &&... args) -> std::future<decltype(f(args...))>
    std::future<decltype(f(args...))>：返回future，调用者可以通过future获取返回值
    返回值后置
    */
    template <class F, class... Args>
    auto exec(int64_t timeoutMs, F&& f, Args&&... args) -> std::future<decltype(f(args...))>
    {
        int64_t expireTime =  (timeoutMs == 0 ? 0 : TNOWMS + timeoutMs);  // 获取现在时间
        //定义返回值类型
        using RetType = decltype(f(args...));  // 推导返回值
        // 封装任务
        auto task = std::make_shared<std::packaged_task<RetType()>>(std::bind(std::forward<F>(f), std::forward<Args>(args)...));

        TaskFuncPtr fPtr = std::make_shared<TaskFunc>(expireTime);  // 封装任务指针，设置过期时间
        fPtr->_func = [task]() {  // 具体执行的函数
            (*task)();
        };

        std::unique_lock<std::mutex> lock(mutex_);
        tasks_.push(fPtr);              // 插入任务
        condition_.notify_one();        // 唤醒阻塞的线程，可以考虑只有任务队列为空的情况再去notify

        return task->get_future();;
    }

    /**
    * @brief 等待当前任务队列中, 所有工作全部结束(队列无任务).
    *
    * @param millsecond 等待的时间(ms), -1:永远等待
    * @return           true, 所有工作都处理完毕
    *                   false,超时退出
    */
    bool waitForAllDone(int millsecond = -1);

protected:
    /**
    * @brief 获取任务
    *
    * @return TaskFuncPtr
    */
    bool get(TaskFuncPtr&task);

    /**
    * @brief 线程池是否退出
    */
    bool isTerminate() { return bTerminate_; }

    /**
    * @brief 线程运行态
    */
    void run();

protected:

    /**
    * 任务队列
    */
    queue<TaskFuncPtr> tasks_;

    /**
    * 工作线程
    */
    std::vector<std::thread*> threads_; //vector 大致可以认为是一个可变数组

    std::mutex                mutex_;

    std::condition_variable   condition_;

    size_t                    threadNum_;

    bool                      bTerminate_;

    std::atomic<int>          atomic_{ 0 };
};

#endif // ZERO_THREADPOOL_H


#include "zero_threadpool.h"

ZERO_ThreadPool::ZERO_ThreadPool()
    :  threadNum_(1), bTerminate_(false)
{
} 

ZERO_ThreadPool::~ZERO_ThreadPool()
{
    stop();
}

bool ZERO_ThreadPool::init(size_t num)
{
    std::unique_lock<std::mutex> lock(mutex_);

    if (!threads_.empty())
    {
        return false;
    }

    threadNum_ = num; // 设置线程数量
    return true;
}

void ZERO_ThreadPool::stop()
{
    {
        std::unique_lock<std::mutex> lock(mutex_);  //加锁

        bTerminate_ = true;     // 触发退出

        condition_.notify_all();
    }

    for (size_t i = 0; i < threads_.size(); i++)
    {
        if(threads_[i]->joinable())
        {
            threads_[i]->join(); // 等线程推出
        }
        delete threads_[i];
        threads_[i] = NULL;
    }

    std::unique_lock<std::mutex> lock(mutex_);
    threads_.clear();
}

bool ZERO_ThreadPool::start()
{
    std::unique_lock<std::mutex> lock(mutex_);

    if (!threads_.empty())
    {
        return false;
    }

    for (size_t i = 0; i < threadNum_; i++)
    {
        threads_.push_back(new thread(&ZERO_ThreadPool::run, this));
    }
    return true;
}

bool ZERO_ThreadPool::get(TaskFuncPtr& task)
{
    std::unique_lock<std::mutex> lock(mutex_); // 也要等锁

    if (tasks_.empty()) // 判断是否任务存在
    {
        condition_.wait(lock, [this] { return bTerminate_  // 要终止线程池 bTerminate_设置为true，外部notify后
                    || !tasks_.empty();  // 任务队列不为空
        }); // notify ->  1. 退出线程池； 2.任务队列不为空
    }

    if (bTerminate_)
        return false;

    if (!tasks_.empty())
    {
        task = std::move(tasks_.front());  // 使用了移动语义

        tasks_.pop(); // 释放一个任务

        return true;
    }

    return false;
}

void ZERO_ThreadPool::run()  // 执行任务的线程
{
    //调用处理部分
    while (!isTerminate()) // 判断是不是要停止
    {
        TaskFuncPtr task;
        bool ok = get(task);        // 1. 读取任务
        if (ok)
        {
            ++atomic_;
            try
            {
                if (task->_expireTime != 0 && task->_expireTime  < TNOWMS )
                {
                    //超时任务，是否需要处理?
                }
                else
                {
                    task->_func();  // 2. 执行任务
                }
            }
            catch (...)
            {
            }

            --atomic_;

            //任务都执行完毕了
            std::unique_lock<std::mutex> lock(mutex_);
            if (atomic_ == 0 && tasks_.empty()) // 3.检测是否所有任务都运行完毕
            {
                condition_.notify_all();  // 这里只是为了通知waitForAllDone
            }
        }
    }
}
// 1000ms
bool ZERO_ThreadPool::waitForAllDone(int millsecond)
{
    std::unique_lock<std::mutex> lock(mutex_);

    if (tasks_.empty())
        return true;

    if (millsecond < 0)
    {
        condition_.wait(lock, [this] { return tasks_.empty(); });
        return true;
    }
    else
    {
        return condition_.wait_for(lock, std::chrono::milliseconds(millsecond), [this] { return tasks_.empty(); });
    }
}


int gettimeofday(struct timeval &tv)
{
#if WIN32
    time_t clock;
    struct tm tm;
    SYSTEMTIME wtm;
    GetLocalTime(&wtm);
    tm.tm_year   = wtm.wYear - 1900;
    tm.tm_mon   = wtm.wMonth - 1;
    tm.tm_mday   = wtm.wDay;
    tm.tm_hour   = wtm.wHour;
    tm.tm_min   = wtm.wMinute;
    tm.tm_sec   = wtm.wSecond;
    tm. tm_isdst  = -1;
    clock = mktime(&tm);
    tv.tv_sec = clock;
    tv.tv_usec = wtm.wMilliseconds * 1000;

    return 0;
#else
    return ::gettimeofday(&tv, 0);
#endif
}

void getNow(timeval *tv)
{
#if TARGET_PLATFORM_IOS || TARGET_PLATFORM_LINUX

    int idx = _buf_idx;
    *tv = _t[idx];
    if(fabs(_cpu_cycle - 0) < 0.0001 && _use_tsc)
    {
        addTimeOffset(*tv, idx);
    }
    else
    {
        TC_Common::gettimeofday(*tv);
    }
#else
    gettimeofday(*tv);
#endif
}

int64_t getNowMs()
{
    struct timeval tv;
    getNow(&tv);

    return tv.tv_sec * (int64_t)1000 + tv.tv_usec / 1000;
}

下面是使用该线程池的测试代码

#include <iostream>
#include "zero_threadpool.h"
using namespace std;

void func0()
{
    cout << "func0()" << endl;
}

void func1(int a)
{
    cout << "func1 int =" << a << endl;
}

//void func1(string a)
//{
//    cout << "func1 string =" << a << endl;
//}

void func2(int a, string b)
{
    cout << "func2() a=" << a << ", b=" << b<< endl;
}


void test1() // 简单测试线程池
{
    ZERO_ThreadPool threadpool;     // 封装一个线程池
    threadpool.init(1);             // 设置线程的数量
    threadpool.start();              // 启动线程池，创建线程， 线程没有start，创建完毕后被调度
    // 假如要执行的任务
//    threadpool.exec(1000,func0); // 1000是超时1000的意思，目前没有起作用
    threadpool.exec(func1, 10);
//    threadpool.exec((void(*)(int))func1, 10);   // 插入任务
//    threadpool.exec((void(*)(string))func1, "king");
    threadpool.exec(func2, 20, "darren"); // 插入任务
    threadpool.waitForAllDone(); // 等待都执行完退出 运行函数 插入1000个任务， 等1000个任务执行完毕才退出
    threadpool.stop();      // 这里才是真正执行退出
}

int func1_future(int a)
{
    cout << "func1() a=" << a << endl;
    return a;
}

string func2_future(int a, string b)
{
    cout << "func1() a=" << a << ", b=" << b<< endl;
    return b;
}

void test2() // 测试任务函数返回值
{
    ZERO_ThreadPool threadpool;
    threadpool.init(1);
    threadpool.start(); // 启动线程池
    // 假如要执行的任务
    std::future<decltype (func1_future(0))> result1 = threadpool.exec(func1_future, 10);
    std::future<string> result2 = threadpool.exec(func2_future, 20, "darren");
//  auto result2 = threadpool.exec(func2_future, 20, "darren");

    std::cout << "result1: " << result1.get() << std::endl;
    std::cout << "result2: " << result2.get() << std::endl;
    threadpool.waitForAllDone();
    threadpool.stop();
}

class Test
{
public:
    int test(int i){
        cout << _name << ", i = " << i << endl;
        return i;
    }
//    int test(string str) {
//        cout << _name << ", str = " << str << endl;
//    }
    void setName(string name){
        _name = name;
    }
    string _name;
};

void test3() // 测试类对象函数的绑定
{
    ZERO_ThreadPool threadpool;
    threadpool.init(1);
    threadpool.start(); // 启动线程池
    Test t1;
    Test t2;
    t1.setName("Test1");
    t2.setName("Test2");
    auto f1 = threadpool.exec(std::bind(&Test::test, &t1, std::placeholders::_1), 10);
    auto f2 = threadpool.exec(std::bind(&Test::test, &t2, std::placeholders::_1), 20);
    threadpool.waitForAllDone();
    cout << "t1 " << f1.get() << endl;
    cout << "t2 " << f2.get() << endl;
}

void func2_1(int a, int b)
{
    cout << "func2_1 a + b = " << a+b << endl;
}

int func2_1(string a, string b)
{
    cout << "func2_1 a + b = " << a << b<< endl;
    return 0;
}
void test4() // 简单测试线程池
{
    ZERO_ThreadPool threadpool;     // 封装一个线程池
    threadpool.init(1);             // 设置线程的数量
    threadpool.start();              // 启动线程池，创建线程， 线程没有start，创建完毕后被调度
    // 假如要执行的任务
    threadpool.exec((void(*)(int, int))func2_1, 10, 20);   // 插入任务
    threadpool.exec((int(*)(string, string))func2_1, "king", " and darren");
    threadpool.waitForAllDone(); // 等待都执行完退出 运行函数 插入1000个任务， 等1000个任务执行完毕才退出
    threadpool.stop();      // 这里才是真正执行退出
}

int main()
{
   test1(); // 简单测试线程池
// //    test2(); // 测试任务函数返回值
// //    test3(); // 测试类对象函数的绑定
//     test4();
    cout << "main finish!" << endl;
    return 0;
}
毛毛不怕困难
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基于C++11新特性手写线程池实现
m0_70418130的博客
09-11 629
线程池封装在ZERO_ThreadPool类中，以下从几个函数代码去分析线程池的原理。线程池采用C++11实现，包括不限于右值引用move，类型推导decltype、aouto，模板函数，可变参数，lambda表达式等新特性。
C++进阶（二）线程池、异常处理、协程
芸兮的博客
12-31 434
title: C++进阶（二）C++新特性：智能指针、右值引用、lambda、多线程操作、function和bind、可变模板参数description: C++进阶（二）C++新特性：智能指针、右值引用、lambda、多线程操作、function和bind、可变模板参数tag: C++
ThreadPool 源码解析
lw_yang的博客
07-09 391
在工作中我们经常会用到线程池，那你知道线程池底层是怎么运作的吗？
C++ 线程池
kakaka666的博客
03-07 760
本文使用C++11实现实现线程池，涉及的技术如下：可变参数decltypebind支持可变参数列表支持获取任务返回值。
ThreadPool 线程池
m0_54202121的博客
04-25 4695
文章目录ThreadPool 线程池线程池简介(三大方法，七大参数，四大策略)Executor类线程池参数说明拒绝策略(重点)Executors线程池的方法与创建newCachedThreadPool(常用)(可扩容)newFixedThreadPool(常用)(固定)newSingleThreadExecutor(常用)(单个)线程池的提交方式execute()submit()线程池的关闭方式 ThreadPool 线程池 三大方法： newSingleThreadExecutor(常用)(单个)–&
c++线程池经典实现方式demo
05-10
C++线程池是一种高效的多线程管理机制，它允许我们将任务提交到一个预先创建好的线程集合中，由线程池统一管理和调度。这种方式可以避免频繁地创建和销毁线程，提高系统的性能和响应速度。下面将详细介绍C++线程池的...
Tpool:基于POSIX pthread的C++线程池实现
06-18
假设你要编写一个web服务器，并在线程池中处理传入的请求，那么你可以编写如下代码来完成这个任务： # include " FixedThreadPool.h " # include # include < tcp> // note that this is a fake header, for ...
一种类似JAVA线程池的C++线程池实现方法
08-25
线程池是多线程编程中的一个重要概念，它旨在提高系统效率，降低资源消耗。当一个程序需要执行大量短生命周期的任务时，线程池能够避免频繁地创建和销毁线程，减少上下文切换的开销，同时保持系统的稳定性和响应速度...
c++线程池实现方法
12-31
下面这个线程池是我在工作中用到过的，原理还是建立一个任务队列，让多个线程互斥的在队列中取出任务，然后执行，显然，队列是要加锁的 环境：ubuntu linux 文件名：locker.h #ifndef LOCKER_H_ #define LOCKER_H_ ...
c++ 线程池实现及安全队列
05-09
下面是一个简化的线程池实现的伪代码： ```cpp class ThreadPool { public: void enqueue(std::function()> task); // 提交任务 ~ThreadPool(); // 关闭线程池 private: std::vector<std::thread> workers; // ...
四大线程池详解
热门推荐
Zero
08-30 3万+
new Thread 的弊端首先看一段代码：/** * Created by Zero on 2017/8/30. */ public class ThreadTest { public static void main(String[] args) { while (true) { new Thread(new Runnable() {
线程池 ThreadPool 常用的四种
qing_mei_xiu的博客
03-28 1010
线程池 ThreadPool 常用的四种 1.为什么用线程池 执行一个异步任务你还只是如下new Thread吗？ 复制代码 new Thread(new Runnable() { @Override public void run() { // TODO Auto-generated method stub } }).start(); 复制代码 那你就out太多...
线程池原理（三）：ThreadPoolExecutor
千磨万击还坚韧，任尔东西南北风
08-29 2196
ThreadPoolExecutor就是我们经常说的大名鼎鼎的线程池，Executors工厂创建的线程池都是该类的实例，通过调节参数的大小创建适用于各个场景的线程池。
线程池ThreadPool详解
qq_43651945的博客
05-11 9060
线程池介绍 可以复用线程池的每一个资源 控制资源的总量 为什么要使用线程池 问题一：反复创建线程开销大 问题二：过多的线程会占用太多内存 解决以上两个问题的思路 • 用少量的线程——避免内存占用过多 • 让这部分线程都保持工作，且可以反复执行任务——避免生命周期的损耗 线程池的好处 加快响应速度 合理利用CPU和内存 统一管理 线程池的应用场合 服务器接收到大量请求时，使用线程池技术是非常合适的，它可以大大减少线程的创建和销毁次数，提高服务器的工作效率 实际上，在开发中，如果需要创建5个以
线程池(ThreadPool)
冲出仁川，走出马德里，故事还会再继续
11-29 3021
线程池ThreadPool1、线程池简介2、线程池参数说明(重点)2.1 常用参数说明2.2 拒绝策略(重点)3、线程池底层工作原理4、入门案例 1、线程池简介   线程池（英语：thread pool）：一种线程使用模式。线程过多会带来调度开销，进而影响缓存局部性和整体性能。而线程池维护着多个线程，等待着监督管理者分配可并发执行的任务。这避免了在处理短时间任务时创建与销毁线程的代价。线程池不仅能够保证内核的充分利用，还能防止过分调度。   例子： 10 年前单核 CPU 电脑，假的多线程，像马戏团小丑玩多
线程池ThreadPoolExecutor原理
风清云淡
08-16 255
在并发场景下，线程池出镜率是比较高的，线程池的使用可以给我们带来一些好处： 降低资源消耗 通过对线程的重复利用避免了频繁的创建和销毁线程所带来的的开销。 提高相应速度 当有任务产生时，可以直接使用现有的空闲线程，无需去创建。 提高对线程的管理 并发情况下往往会有很多线程运行，但线程不能无限度的创建运行，因为线程也是需要占用资源，过多的线程导致系统可用资源急剧下降，降低系统稳定性。线程池的使用可以...
异步多线程之ThreadPool详解
菜鸟厚非
11-17 8211
ThreadPool
C++ 继承篇
2301_79201049的博客
07-18 692
必须对继承而来的成员进行初始化直接通过初始化列表或者赋值的方式进行初始化调用父类构造函数进行初始化
商品信息管理系统(C语言)
最新发布
zeyeqianli的博客
07-22 227
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
实现一个C++线程池
02-17
的方法有哪些？ C语言的线程池实现方法有很多，其中一些常见的方法包括： 1. 使用系统调用，例如pthread_create，pthread_join等。 2. 使用第三方库，例如libevent，libev等。 3. 自己实现一个线程池，例如使用队列来管理线程，实现线程的创建、销毁等。 每种方法都有其优缺点，需要根据具体需求来选择最适合的方法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值