C++ 11线程池

最新推荐文章于 2025-04-16 14:04:37 发布

云中飞鸿--**峰

最新推荐文章于 2025-04-16 14:04:37 发布

阅读量390

点赞数

分类专栏： # C++提升文章标签： c++ 算法

原文链接：https://blog.youkuaiyun.com/kenjianqi1647/article/details/110834293

版权

C++提升专栏收录该内容

20 篇文章

订阅专栏

一、基本概念
1.1 为什么要用线程池
创建/销毁线程伴随着系统开销，过于频繁的创建和销毁线程会影响程序的处理效率：

如创建线程消耗时间为T1，执行任务消耗时间为T2,销毁线程消耗时间为T3，若T1+T3 > T2 ,则开启一个线程执行该任务不划算。

1.2 线程池的基本思想
因为程序边运行边创建线程是比较耗时的，所以我们通过池化的思想：在程序开始运行前创建多个线程这样，程序在运行时，只需要从线程池中拿来用就可以了．大大提高了程序运行效率。

1.3线程池的组成
（1）线程池管理器

创建一定数量的线程，启动线程，调配任务，管理着线程池。
本篇线程池目前只需要启动(start())，停止方法(stop())，及任务添加方法(addTask).
start()创建一定数量的线程池,进行线程循环.
stop()停止所有线程循环，回收所有资源.
addTask()添加任务.

（2）工作线程

线程池中线程，在线程池中等待并执行分配的任务，本篇选用条件变量实现等待与通知机制.

（3）任务接口

添加任务的接口,以供工作线程调度任务的执行。

（4）任务队列

用于存放没有处理的任务。提供一种缓冲机制，同时任务队列具有调度功能，高优先级的任务放在任务队列前面

1.4 线程池的分类
分为半同步半异步线程池和领导者追随者线程池。

二、线程池实例
定义：threadpool.h

#pragma once
#ifndef THREAD_POOL_H
#define THREAD_POOL_H
// 使用#pragma once  和 #ifndef THREAD_POOL_H 是为了避免同一个文件被include多次
#include <vector>
#include <queue>
#include <atomic>
#include <future>
#include <condition_variable>
#include <thread>
#include <functional>
#include <stdexcept>
namespace std
{
//线程池最大容量,应尽量设小一点
#define  THREADPOOL_MAX_NUM 16
//#define  THREADPOOL_AUTO_GROW
 
//线程池,可以提交变参函数或拉姆达表达式的匿名函数执行,可以获取执行返回值
//不直接支持类成员函数, 支持类静态成员函数或全局函数,Opteron()函数等
    class threadpool
    {
        using Task = function<void()>;    //定义类型
        vector<thread> _pool;     //线程池
        queue<Task> _tasks;            //任务队列
        mutex _lock;                   //同步
        condition_variable _task_cv;   //条件阻塞
        atomic<bool> _run{ true };     //线程池是否执行
        atomic<int>  _idlThrNum{ 0 };  //空闲线程数量
 
    public:
        inline threadpool(unsigned short size = 4) { addThread(size); }
        inline ~threadpool()
        {
            _run = false;
            _task_cv.notify_all(); // 唤醒所有线程执行
            for (thread& thread : _pool) {
                //thread.detach(); // 让线程“自生自灭”
                if (thread.joinable())
                    thread.join(); // 等待任务结束， 前提：线程一定会执行完
            }
        }
 
    public:
        // 提交一个任务
        // 调用.get()获取返回值会等待任务执行完,获取返回值
        // 有两种方法可以实现调用类成员，
        // 一种是使用   bind： .commit(std::bind(&Dog::sayHello, &dog));
        // 一种是用   mem_fn： .commit(std::mem_fn(&Dog::sayHello), this)
        template<class F, class... Args>
        auto commit(F&& f, Args&&... args) ->future<decltype(f(args...))>
        {
            if (!_run)    // stoped ??
                throw runtime_error("commit on ThreadPool is stopped.");
 
            using RetType = decltype(f(args...)); // typename std::result_of<F(Args...)>::type, 函数 f 的返回值类型
            auto task = make_shared<packaged_task<RetType()>>(
                bind(forward<F>(f), forward<Args>(args)...)
                ); // 把函数入口及参数,打包(绑定)
            future<RetType> future = task->get_future();
            {    // 添加任务到队列
                lock_guard<mutex> lock{ _lock };//对当前块的语句加锁  lock_guard 是 mutex 的 stack 封装类，构造的时候 lock()，析构的时候 unlock()
                _tasks.emplace([task]() { // push(Task{...}) 放到队列后面
                    (*task)();
                    });
            }
#ifdef THREADPOOL_AUTO_GROW
            if (_idlThrNum < 1 && _pool.size() < THREADPOOL_MAX_NUM)
                addThread(1);
#endif // !THREADPOOL_AUTO_GROW
            _task_cv.notify_one(); // 唤醒一个线程执行
 
            return future;
        }
 
        //空闲线程数量
        int idlCount() { return _idlThrNum; }
        //线程数量
        int thrCount() { return _pool.size(); }
#ifndef THREADPOOL_AUTO_GROW
    private:
#endif // !THREADPOOL_AUTO_GROW
        //添加指定数量的线程
        void addThread(unsigned short size)
        {
            for (; _pool.size() < THREADPOOL_MAX_NUM && size > 0; --size)
            {   //增加线程数量,但不超过 预定义数量 THREADPOOL_MAX_NUM
                _pool.emplace_back([this] { //工作线程函数
                    while (_run)
                    {
                        Task task; // 获取一个待执行的 task
                        {
                            // unique_lock 相比 lock_guard 的好处是：可以随时 unlock() 和 lock()
                            unique_lock<mutex> lock{ _lock };
                            _task_cv.wait(lock, [this] {
                                return !_run || !_tasks.empty();
                                }); // wait 直到有 task
                            if (!_run && _tasks.empty())
                                return;
                            task = move(_tasks.front()); // 按先进先出从队列取一个 task
                            _tasks.pop();
                        }
                        _idlThrNum--;
                        task();//执行任务
                        _idlThrNum++;
                    }
                    });
                _idlThrNum++;
            }
        }
    };
 
}
 
 
#endif

使用线程池 main.cpp

// test_thread_pool.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//
 
#include <iostream>
#include <atomic>
#include <condition_variable>
#include <functional>
#include <future>
#include <mutex>
#include <queue>
#include <string>
#include <thread>
#include <vector>
#include "threadpool.h"
using namespace std;
 
void fun1(int slp)
{
    printf("  hello, fun1 !  %d\n", std::this_thread::get_id());
    if (slp > 0) {
        printf(" ======= fun1 sleep %d  =========  %d\n", slp, std::this_thread::get_id());
        std::this_thread::sleep_for(std::chrono::milliseconds(slp));
        //Sleep(slp );
    }
}
 
struct gfun {
    int operator()(int n) {
        printf("%d  hello, gfun !  %d\n", n, std::this_thread::get_id());
        return 42;
    }
};
 
class A {    //函数必须是 static 的才能使用线程池
public:
    static int Afun(int n = 0) {
        std::cout << n << "  hello, Afun !  " << std::this_thread::get_id() << std::endl;
        return n;
    }
 
    static std::string Bfun(int n, std::string str, char c) {
        std::cout << n << "  hello, Bfun !  " << str.c_str() << "  " << (int)c << "  " << std::this_thread::get_id() << std::endl;
        return str;
    }
};
 
int main()
{
    try {
        std::threadpool executor{ 50 };
        A a;
        std::future<void> ff = executor.commit(fun1, 0);
        std::future<int> fg = executor.commit(gfun{}, 0);
        std::future<int> gg = executor.commit(a.Afun, 9999); //IDE提示错误,但可以编译运行
        std::future<std::string> gh = executor.commit(A::Bfun, 9998, "mult args", 123);
        std::future<std::string> fh = executor.commit([]()->std::string { std::cout << "hello, fh !  " << std::this_thread::get_id() << std::endl; return "hello,fh ret !"; });
 
        std::cout << " =======  sleep ========= " << std::this_thread::get_id() << std::endl;
        std::this_thread::sleep_for(std::chrono::microseconds(900));
 
        for (int i = 0; i < 50; i++) {
            executor.commit(fun1, i * 100);
        }
        std::cout << " =======  commit all ========= " << std::this_thread::get_id() << " idlsize=" << executor.idlCount() << std::endl;
 
        std::cout << " =======  sleep ========= " << std::this_thread::get_id() << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(3));
 
        ff.get(); //调用.get()获取返回值会等待线程执行完,获取返回值
        std::cout << fg.get() << "  " << fh.get().c_str() << "  " << std::this_thread::get_id() << std::endl;
 
        std::cout << " =======  sleep ========= " << std::this_thread::get_id() << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(3));
 
        std::cout << " =======  fun1,55 ========= " << std::this_thread::get_id() << std::endl;
        executor.commit(fun1, 55).get();    //调用.get()获取返回值会等待线程执行完
 
        std::cout << "end... " << std::this_thread::get_id() << std::endl;
 
 
        std::threadpool pool(4);
        std::vector< std::future<int> > results;
 
        for (int i = 0; i < 8; ++i) {
            results.emplace_back(
                pool.commit([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::cout << " =======  commit all2 ========= " << std::this_thread::get_id() << std::endl;
 
        for (auto&& result : results)
            std::cout << result.get() << ' ';
        std::cout << std::endl;
        return 0;
    }
    catch (std::exception & e) {
        std::cout << "some unhappy happened...  " << std::this_thread::get_id() << e.what() << std::endl;
    }
 
 
}

语法讲解：

（1）使用#pragma once 和 #ifndef THREAD_POOL_H 是为了避免同一个文件被include多次

#pragma once
#ifndef THREAD_POOL_H
#define THREAD_POOL_H

#endif

（2）using Task = function<void()>; //定义类型

通常std::function是一个函数对象类，它包装其它任意的函数对象。std::function的实例可以对任何可以调用的目标实体进行存储、复制、和调用操作，这些目标实体包括普通函数、Lambda表达式、函数指针、以及其它函数对象等。

std::function< int(int)> Functional;
 
// 普通函数
int TestFunc(int a)
{
    return a;
}
 // 普通函数
 Functional = TestFunc;
 int result = Functional(10);
 cout << "普通函数："<< result << endl;

function<void()> 可以认为是一个函数类型，接受任意原型是 void() 的函数，或是函数对象，或是匿名函数。void() 意思是不带参数，没有返回值。

（3）std::mutex 与 std::condition_variable

std::condition_variable 是条件变量，当 std::condition_variable 对象的某个 wait 函数被调用的时候，它使用 std::unique_lock(通过 std::mutex) 来锁住当前线程。当前线程会一直被阻塞，直到另外一个线程在相同的 std::condition_variable 对象上调用了 notification 函数来唤醒当前线程。

#include <iostream>                // std::cout
#include <thread>                // std::thread
#include <mutex>                // std::mutex, std::unique_lock
#include <condition_variable>    // std::condition_variable
 
std::mutex mtx; // 全局互斥锁.
std::condition_variable cv; // 全局条件变量.
bool ready = false; // 全局标志位.
 
void do_print_id(int id)
{
    std::unique_lock <std::mutex> lck(mtx);
    while (!ready) // 如果标志位不为 true, 则等待...
        cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,
    // 线程被唤醒, 继续往下执行打印线程编号id.
    std::cout << "thread " << id << '\n';
}
void go()
{
    std::unique_lock <std::mutex> lck(mtx);
    ready = true; // 设置全局标志位为 true.
    cv.notify_all(); // 唤醒所有线程.
}
 
int main()
{
    std::thread threads[10];
    // spawn 10 threads:
    for (int i = 0; i < 10; ++i)
        threads[i] = std::thread(do_print_id, i);
 
    std::cout << "10 threads ready to race...\n";
    go(); // go!
 
  for (auto & th:threads)
        th.join();
 
    return 0;
}

（4）atomic<bool>

在新标准C++11，引入了原子操作的概念，并通过这个新的头文件提供了多种原子操作数据类型，例如，atomic_bool,atomic_int等。

如果我们在多个线程中对这些类型的共享资源进行操作，编译器将保证这些操作都是原子性的，也就是说，确保任意时刻只有一个线程对这个资源进行访问，编译器将保证，多个线程访问这个共享资源的正确性。从而避免了锁的使用，提高了效率。

std::atomic<bool> a(true);　　　　//定义一个类型为atomic_bool的原子变量并赋初值为true
原子操作:
赋值:
a = true;
a.store(true);
 
读取:
int b = a;
int b = a.load();

（5）template<class F, class... Args> 可变参数模板

C++11的新特性--可变模版参数（variadic templates）是C++11新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。

声明一个可变模版参数：template<typename...>或者template<class...>

template <class... T>
void f(T... args);

可变模版参数和普通的模版参数语义是一致的，所以可以应用于函数和类，即可变模版参数函数和可变模版参数类，然而，模版函数不支持偏特化，所以可变模版参数函数和可变模版参数类展开可变模版参数的方法还不尽相同，展开方式有两种，递归函数方式展开参数包和逗号表达式展开参数包。如逗号表达式展开参数包：

template <class T>
void printarg(T t)
{
   cout << t << endl;
}
 
template <class ...Args>
void expand(Args... args)
{
   int arr[] = {(printarg(args), 0)...};
}
 
expand(1,2,3,4);

（6）decltype关键字

从表达式的类型推断出要定义的变量类型，但是不想用该表达式的值初始化变量（如果要初始化就用auto了）。为了满足这一需求，C++11新标准引入了decltype类型说明符，它的作用是选择并返回操作数的数据类型，在此过程中，编译器分析表达式并得到它的类型，却不实际计算表达式的值。

 int tempA = 2;
    
//1.dclTempA为int
decltype(tempA) dclTempA;
//2.dclTempB为int，对于getSize根本没有定义，但是程序依旧正常，因为decltype只做分析，并不调用getSize
decltype(getSize()) dclTempB;

（7）std::future 使用

C++11提供了std::future类模板，future对象提供访问异步操作结果的机制，很轻松解决从异步任务中返回结果。

在C++标准库中，有两种“期望”，使用两种类型模板实现，

唯一期望(unique futures，std::future<>) std::future的实例只能与一个指定事件相关联。
共享期望(shared futures)(std::shared_future<>) std::shared_future的实例就能关联多个事件。

template< class T > 
class future;
//数据有关的期望
template< class T > 
class future<T&>;
//数据无关的期望
template<>          
class future<void>;

std::async 、 std::packaged_task 或 std::promise 能提供一个std::future对象给该异步操作的创建者commit函数用于传入真正的任务，外部操作线程池主要调用commit函数，传入一个任务函数到线程池。

future<decltype(f(args...))> 用参数来推断返回值并且转成future类型。

（8） std::packaged_task

std::packaged_task 包装一个可调用的对象，并且允许异步获取该可调用对象产生的结果，从包装可调用对象意义上来讲，std::packaged_task 与 std::function 类似，只不过 std::packaged_task 将其包装的可调用对象的执行结果传递给一个 std::future 对象。

std::packaged_task 对象内部包含了两个最基本元素，一、被包装的任务(stored task)，任务(task)是一个可调用的对象，如函数指针、成员函数指针或者函数对象，二、共享状态(shared state)，用于保存任务的返回值，可以通过 std::future 对象来达到异步访问共享状态的效果。

#include <iostream>     // std::cout
#include <future>       // std::packaged_task, std::future
#include <chrono>       // std::chrono::seconds
#include <thread>       // std::thread, std::this_thread::sleep_for
 
// count down taking a second for each value:
int countdown (int from, int to) {
    for (int i=from; i!=to; --i) {
        std::cout << i << '\n';
        std::this_thread::sleep_for(std::chrono::seconds(1));
    }
    std::cout << "Finished!\n";
    return from - to;
}
 
int main ()
{
    std::packaged_task<int(int,int)> task(countdown); // 设置 packaged_task
    std::future<int> ret = task.get_future(); // 获得与 packaged_task 共享状态相关联的 future 对象.
 
    std::thread th(std::move(task), 10, 0);   //创建一个新线程完成计数任务.
 
    int value = ret.get();                    // 等待任务完成并获取结果.
 
    std::cout << "The countdown lasted for " << value << " seconds.\n";
 
    th.join();
    return 0;
}

执行结果：

10
9
8
7
6
5
4
3
2
1
Finished!
The countdown lasted for 10 seconds.

原文链接：https://blog.youkuaiyun.com/kenjianqi1647/article/details/110834293