C++11 线程池实现

ThreadPool.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#include <vector>
#include <queue>
#include <atomic>
#include <future>
#include <condition_variable>
#include <thread>
#include <functional>
#include <stdexcept>

using 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(bind(&Dog::sayHello, &dog));
// 一种是用 mem_fn: .commit(mem_fn(&Dog::sayHello), this)
template <typename F, typename ... 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...)); // 函数 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};
_tasks.emplace([task]() { (*task)(); }); // push(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)
{
_pool.emplace_back([this] {
while (_run)
{
Task task; // 获取一个待执行的 task
{
unique_lock<mutex> lock{_lock};
_task_cv.wait(lock, [this] { return !_run || !_tasks.empty(); });
if (!_run && _tasks.empty())
return;
task = move(_tasks.front()); // 按先进先出从队列取一个 task
_tasks.pop();
}
_idlThrNum--;
task(); // 执行任务
_idlThrNum++;
}
});
_idlThrNum++;
}
}
};

测试 main.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include <iostream>
#include "ThreadPool.h"
void fun1(int slp)
{
printf(" hello, fun1 ! %d\n", this_thread::get_id());
if (slp > 0)
{
printf(" ======= fun1 sleep %d ========= %d\n", slp, this_thread::get_id());
this_thread::sleep_for(chrono::milliseconds(slp));
}
}

struct gfun
{
int operator()(int n)
{
printf("%d hello, gfun ! %d\n", n, this_thread::get_id());
return 42;
}
};

class A
{ //函数必须是 static 的才能使用线程池
public:
static int Afun(int n = 0)
{
cout << n << " hello, Afun ! " << this_thread::get_id() << endl;
return n;
}

static string Bfun(int n, string str, char c)
{
cout << n << " hello, Bfun ! " << str.c_str() << " " << (int)c << " " << this_thread::get_id() << endl;
return str;
}
};

int main()
{
try
{
ThreadPool executor{50};
A a;
future<void> ff = executor.commit(fun1, 0);
future<int> fg = executor.commit(gfun{}, 0);
future<int> gg = executor.commit(a.Afun, 9999); //IDE提示错误,但可以编译运行
future<string> gh = executor.commit(A::Bfun, 9998, "mult args", 123);
future<string> fh = executor.commit([]() -> string { cout << "hello, fh ! " << this_thread::get_id() << endl; return "hello,fh ret !"; });

cout << " ======= sleep ========= " << this_thread::get_id() << endl;
this_thread::sleep_for(chrono::microseconds(900));

for (int i = 0; i < 50; i++)
{
executor.commit(fun1, i * 100);
}
cout << " ======= commit all ========= " << this_thread::get_id() << " idlsize=" << executor.idlCount() << endl;

cout << " ======= sleep ========= " << this_thread::get_id() << endl;
this_thread::sleep_for(chrono::seconds(3));

ff.get(); //调用.get()获取返回值会等待线程执行完,获取返回值
cout << fg.get() << " " << fh.get().c_str() << " " << this_thread::get_id() << endl;

cout << " ======= sleep ========= " << this_thread::get_id() << endl;
this_thread::sleep_for(chrono::seconds(3));

cout << " ======= fun1,55 ========= " << this_thread::get_id() << endl;
executor.commit(fun1, 55).get(); //调用.get()获取返回值会等待线程执行完

cout << "end... " << this_thread::get_id() << endl;

ThreadPool pool(4);
vector<future<int>> results;

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

for (auto &&result : results)
cout << result.get() << ' ';
cout << endl;
return 0;
}
catch (exception &e)
{
cout << "some unhappy happened... " << this_thread::get_id() << e.what() << endl;
}
}

知识点

  1. using Task = function<void()> 是类型别名,简化了 typedef 的用法。function<void()> 可以认为是一个函数类型,接受任意原型是 void() 的函数,或是函数对象,或是匿名函数。void() 意思是不带参数,没有返回值。
  2. pool.emplace_back([this]{…}) 和 pool.push_back([this]{…}) 功能一样,只不过前者性能会更好;
  3. pool.emplace_back([this]{…}) 是构造了一个线程对象,执行函数是拉姆达匿名函数 ;
  4. 所有对象的初始化方式均采用了 {},而不再使用 () 方式,因为风格不够一致且容易出错;
  5. 匿名函数: [this]{…} 不多说。[] 是捕捉器,this 是引用域外的变量 this指针, 内部使用死循环, 由cv_task.wait(lock,[this]{…}) 来阻塞线程;
  6. delctype(expr) 用来推断 expr 的类型,和 auto 是类似的,相当于类型占位符,占据一个类型的位置;auto f(A a, B b) -> decltype(a+b) 是一种用法,不能写作 decltype(a+b) f(A a, B b),为啥?! c++ 就是这么规定的!
  7. commit 方法是不是略奇葩!可以带任意多的参数,第一个参数是 f,后面依次是函数 f 的参数(注意:参数要传struct/class的话,建议用pointer,小心变量的作用域)! 可变参数模板是 c++11 的一大亮点,够亮!至于为什么是 Arg… 和 arg… ,因为规定就是这么用的!
  8. commit 直接使用智能调用stdcall函数,但有两种方法可以实现调用类成员,一种是使用 bind: .commit(std::bind(&Dog::sayHello, &dog)); 一种是用 mem_fn: .commit(std::mem_fn(&Dog::sayHello), &dog);
  9. make_shared 用来构造 shared_ptr 智能指针。用法大体是 shared_ptr p = make_shared(4) 然后 *p == 4 。智能指针的好处就是, 自动 delete !
  10. bind 函数,接受函数 f 和部分参数,返回currying后的匿名函数,譬如 bind(add, 4) 可以实现类似 add4 的函数!
  11. forward() 函数,类似于 move() 函数,后者是将参数右值化,前者是… 肿么说呢?大概意思就是:不改变最初传入的类型的引用类型(左值还是左值,右值还是右值);
  12. packaged_task 就是任务函数的封装类,通过 get_future 获取 future , 然后通过 future 可以获取函数的返回值(future.get());packaged_task 本身可以像函数一样调用 () ;
  13. queue 是队列类, front() 获取头部元素, pop() 移除头部元素;back() 获取尾部元素,push() 尾部添加元素;
  14. lock_guard 是 mutex 的 stack 封装类,构造的时候 lock(),析构的时候 unlock(),是 c++ RAII 的 idea;
  15. condition_variable cv; 条件变量, 需要配合 unique_lock 使用;unique_lock 相比 lock_guard 的好处是:可以随时 unlock() 和 lock()。 cv.wait() 之前需要持有 mutex,wait 本身会 unlock() mutex,如果条件满足则会重新持有 mutex。
  16. 最后线程池析构的时候,join() 可以等待任务都执行完在结束,很安全!
您的支持将鼓励我继续创作!
0%