C++11 —— 使用 thread 实现线程池
1. 引言
在新的 C++11 标准中，引入并发编程的一些基础组件：线程（thread）、互斥锁（mutex）、条件变量（condition_variable） 等，凭借这些，就足够我设计一个平台无关的 线程池 组件了。下面就详细介绍一下这个线程池组件。
2. 结构设计图
需要特别说明的是，这个线程池组件，在增加了“存在关联性的任务对象顺序执行”的功能后，原本的任务队列就分成了两级任务队列，目的是为了降低 “任务提交” 与 “任务提取” 之间（属于一种生产/消费的关系）的锁竞争。
3. 源码说明
源码有点多，这里就不贴出来了，直接给下载地址：https://github.com/Gaaagaa/xthreadpool 。主要的线程池类 x_threadpool_t 在 xthreadpool.h 中已完整实现，在实际项目应用中，只需要 xthreadpool.h 这一个文件就足够了。
测试程序的编译命令：
- MSVC++2017：cl /EHsc main.cpp
- gcc ：g++ -Wall -std=c++11 -lpthread -o main main.cpp
技术特点：
- 使用 C++11 的 thread 实现，可跨平台，亲测的编译器有 MSVC++2017、gcc 4.8.5、gcc 8.2.0；
- 支持传统的面向对象编程的任务对象类接口：继承抽象任务对象接口类，实现多态（可结合对象池的模式进行资源复用）；
- 支持泛型接口的任务对象，如：C 函数接口、lambda 表达式、仿函数对象、类对象的成员函数调用；
- 支持动态调整工作线程的数量：通过 resize() 接口实现，该功能当前的实现方式还不够好，仍有优化的方式；
- 支持运行时的线程状态检测（判断当前工作线程是否需要退出）；
- 存在关联性的任务对象可顺序执行（这一特点只针对一些特别的应用场景，后续示例中会展示）。
4. 使用说明与示例代码
4.1 启动与关闭
#include "xthreadpool.h"
#include <chrono>
#include <stdio.h>
int main(int argc, char * argv[])
{
// 工作线程数量
// 若为 0，将取 hardware_concurrency() 返回值的 2倍 + 1
int nthreads = 4;
// 线程池对象
x_threadpool_t xht_pool;
// 启动线程池
if (!xht_pool.startup(nthreads))
{
printf("startup return false!\n");
return -1;
}
//======================================
// 提交任务对象
// ......
//======================================
// 等待所有任务执行完成
while (xht_pool.task_count() > 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
// 关闭线程池
xht_pool.shutdown();
return 0;
}
4.2 提交“传统 C 回调函数”的任务对象
#include "xthreadpool.h"
#include <chrono>
#include <stdio.h>
void func_task(int task_id, int task_iter)
{
int count = 1;
do
{
printf("func_task[%d, %d] => count: %d\n", task_id, task_iter, count);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
} while (count++ < 10);
}
int main(int argc, char * argv[])
{
// 线程池对象
x_threadpool_t xht_pool;
// 启动线程池
if (!xht_pool.startup(0))
{
printf("startup return false!\n");
return -1;
}
//======================================
// 提交任务对象 : C 函数接口的任务
for (int iter = 0; iter < 100; iter += 10)
{
xht_pool.submit_task_ex(func_task, iter, iter * iter);
}
//======================================
// 等待所有任务执行完成
while (xht_pool.task_count() > 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
// 关闭线程池
xht_pool.shutdown();
return 0;
}
4.3 提交“仿函数对象”的任务对象
#include "xthreadpool.h"
#include <chrono>
#include <stdio.h>
/**
* @struct functor_task_A
* @brief 仿函数模式的任务对象类。
*/
struct functor_task_A
{
// constructor/destructor
public:
functor_task_A(int xtask_id = 0) : m_xtask_id(xtask_id) { }
public:
void operator()() const
{
int count = 1;
do
{
printf("functor_task_A[%d] => count: %d\n", m_xtask_id, count);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
} while (count++ < 10);
}
// data members
private:
int m_xtask_id;
};
/**
* @struct functor_task_B
* @brief 仿函数模式的任务对象类。
*/
struct functor_task_B
{
// constructor/destructor
public:
functor_task_B(int xtask_id = 0) : m_xtask_id(xtask_id) { }
public:
void operator()(int flag) const
{
int count = 1;
do
{
printf("functor_task_B[%d, %d] => count: %d\n", m_xtask_id, flag, count);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
} while (count++ < 10);
}
// data members
private:
int m_xtask_id;
};
int main(int argc, char * argv[])
{
// 线程池对象
x_threadpool_t xht_pool;
// 启动线程池
if (!xht_pool.startup(0))
{
printf("startup return false!\n");
return -1;
}
//======================================
// 提交任务对象 : 仿函数对象
for (int iter = 0; iter < 100; iter += 10)
{
xht_pool.submit_task_ex((functor_task_A(iter)));
}
for (int iter = 0; iter < 100; iter += 10)
{
xht_pool.submit_task_ex((functor_task_B(iter)), iter * iter / 2);
}
//======================================
// 等待所有任务执行完成
while (xht_pool.task_count() > 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
// 关闭线程池
xht_pool.shutdown();
return 0;
}
4.4 提交“调用类对象的成员函数”的任务对象
#include "xthreadpool.h"
#include <chrono>
#include <stdio.h>
/**
* @class memfunc_task
* @brief 调用成员函数的任务对象类。
*/
class memfunc_task
{
// constructor/destructor
public:
memfunc_task(int xtask_id = 0) : m_xtask_id(xtask_id) { }
// overrides
public:
/**********************************************************/
/**
* @brief 任务对象执行流程的操作接口。
*/
void memfunc(int task_iter)
{
int count = 1;
do
{
printf("memfunc_task[%d, %d] => count: %d\n", m_xtask_id, task_iter, count);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
} while (count++ < 10);
}
// data members
private:
int m_xtask_id;
};
int main(int argc, char * argv[])
{
// 线程池对象
x_threadpool_t xht_pool;
// 启动线程池
if (!xht_pool.startup(0))
{
printf("startup return false!\n");
return -1;
}
//======================================
// 提交任务对象
// 注意，这个栈区对象的生命期需要在线程池关闭前存活，
// 至少要保证所提交的任务都执行完成时，才可结束该对象的生命期
memfunc_task mftask(0);
for (int iter = 0; iter < 100; iter += 10)
{
xht_pool.submit_task_ex(&memfunc_task::memfunc, &mftask, iter);
}
//======================================
// 等待所有任务执行完成
while (xht_pool.task_count() > 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
// 关闭线程池
xht_pool.shutdown();
return 0;
}
4.5 提交“重载后的任务对象类”的任务对象
#include "xthreadpool.h"
#include <chrono>
#include <stdio.h>
/**
* @class user_task
* @brief 用户自定义的任务对象类。
*/
class user_task : public x_task_t
{
// constructor/destructor
public:
user_task(int xtask_id = 0) : m_xtask_id(xtask_id) { }
// overrides
public:
/**********************************************************/
/**
* @brief 任务对象执行流程的操作接口。
*/
virtual void run(x_running_checker_t * xchecker_ptr) override
{
int count = 1;
do
{
printf("[%d]user_task[%d] => count: %d\n", (int)xchecker_ptr->thread_index(), m_xtask_id, count);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
} while ((count++ < 10) && xchecker_ptr->is_enable_running());
}
// data members
private:
int m_xtask_id;
};
int main(int argc, char * argv[])
{
// 线程池对象
x_threadpool_t xht_pool;
// 启动线程池
if (!xht_pool.startup(0))
{
printf("startup return false!\n");
return -1;
}
//======================================
// 提交任务对象 : 重载的任务对象
for (int iter = 0; iter < 100; iter += 10)
{
xht_pool.submit_task((x_task_ptr_t)(new user_task(iter)));
}
//======================================
// 等待所有任务执行完成
while (xht_pool.task_count() > 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
// 关闭线程池
xht_pool.shutdown();
return 0;
}
4.6 提交“lambda表达式”的任务对象
#include "xthreadpool.h"
#include <chrono>
#include <stdio.h>
int main(int argc, char * argv[])
{
// 线程池对象
x_threadpool_t xht_pool;
// 启动线程池
if (!xht_pool.startup(0))
{
printf("startup return false!\n");
return -1;
}
//======================================
// 提交任务对象 : lambda 表达式
for (int iter = 0; iter < 100; iter += 10)
{
xht_pool.submit_task_ex(
[iter]() -> void
{
int task_id = iter;
for (int jter = 0; jter < 10; ++jter)
{
printf("lambda A task id : %d -> %d\n", task_id, task_id + jter);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
});
}
for (int iter = 0; iter < 100; iter += 10)
{
xht_pool.submit_task_ex(
[iter](const std::string & str_name) -> void
{
int task_id = iter;
for (int jter = 0; jter < 10; ++jter)
{
printf("lambda B task id : %d -> %d name : %s\n", task_id, task_id + jter, str_name.c_str());
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
}, std::string("Lambda B"));
}
//======================================
// 等待所有任务执行完成
while (xht_pool.task_count() > 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
// 关闭线程池
xht_pool.shutdown();
return 0;
}
4.7 任务对象执行过程中检测工作线程是否可继续运行
x_threadpool_t 内部提供了一个类 x_running_checker_t 可检测当前工作线程是否可继续执行下去（或者说，是否要立即终止执行的任务流程）。提供此功能，主要目的是针对那些耗时长的任务对象（处于运行状态），在线程池关闭或者需要动态调整（减少）工作线程数量时，能够优雅地终止任务流程。参看如下代码是如何使用的：
#include "xthreadpool.h"
#include <chrono>
#include <stdio.h>
int main(int argc, char * argv[])
{
// 线程池对象
x_threadpool_t xht_pool;
// 启动线程池
if (!xht_pool.startup(0))
{
printf("startup return false!\n");
return -1;
}
//======================================
// 提交任务对象 : lambda 表达式（检测工作线程的退出标识）
for (int iter = 0; iter < 100; iter += 10)
{
xht_pool.submit_task_ex(
[iter](x_running_checker_t * xchecker_ptr) -> void
{
int task_id = iter;
for (int jter = 0; (jter < 10) && xchecker_ptr->is_enable_running(); ++jter)
{
printf("rchecker[%d] lambda A task id : %d -> %d\n", (int)xchecker_ptr->thread_index(), task_id, task_id + jter);
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
},
x_running_checker_t::xholder());
}
//======================================
// 等待所有任务执行完成
while (xht_pool.task_count() > 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
// 关闭线程池
xht_pool.shutdown();
return 0;
}
4.8 使某一批任务对象在线程池中可按提交次序而顺序执行
单看 “按提交次序而顺序执行” 这句话，可能不好理解，先看后面提到的这样应用场景。
A 对象产生（需要执行）的任务对象序列为[ A1, A2, ..., Am ]，并按此顺序依次提交到线程池中；与此同时，B 对象产生（需要执行）的任务对象序列为[ B1, B2, ..., Bn ]，也按此顺序依次提交到线程池中。而不管是 A 对象还是 B 对象，都期望按所提交顺序执行任务对象。这种情况下，在线程池中的任务队列可能有如下图所示的排列：
从本质上看，我们只需要保证 A（或 B） 对象产生的任务在同一时刻只能有一个工作线程执行，这就能保证其顺序性。
面对这种应用场景，我在设计任务对象的抽象基类 x_task_t 时，就为此做好了相关的扩展接口。先看下 x_task_t 代码中的两个接口：
struct x_task_t
{
......
// extensible interfaces
public:
......
/**********************************************************/
/**
* @brief 判断 任务对象 是否挂起。
* @note 若任务对象处于挂起状态，工作线程提取任务时，则跳过该对象。
*/
virtual bool is_suspend(void) const { return false; }
/**********************************************************/
/**
* @brief 设置任务对象的运行标识。
*
* @note
* <pre>
* 工作线程在提取到任务对象后，则立即调用 set_running_flag(true) 操作；
* 执行 run() 操作返回后，又调用 set_running_flag(false) 操作。
* </pre>
*/
virtual void set_running_flag(bool xrunning_flag) { }
......
};
再看下 x_threadpool_t 工作线程 “提取任务对象” 以及 “执行任务对象” 的部分实现流程（注意任务对象 is_suspend() 和 set_running_flag() 两个接口被调用的地方）：
class x_threadpool_t
{
......
x_task_ptr_t get_task(void)
{
......
for (std::list< x_task_ptr_t >::iterator itlst = m_lst_run_tasks.begin();
(itlst != m_lst_run_tasks.end()) && is_enable_get_task();
++itlst)
{
if ((nullptr == *itlst) || !(*itlst)->is_suspend())
{
xtask_ptr = *itlst;
m_lst_run_tasks.erase(itlst);
m_xst_lst_tasks.fetch_sub(1);
break;
}
}
if (nullptr != xtask_ptr)
{
xtask_ptr->set_running_flag(true);
}
return xtask_ptr;
}
......
void thread_run(size_t xthread_index)
{
......
xtask_ptr = get_task();
if (nullptr == xtask_ptr)
{
if (get_lst_task_size() > 0)
thread_yield(xcounter);
continue;
}
if (xht_checker.is_enable_running())
{
xtask_ptr->run(&xht_checker);
}
// 执行完任务对象后，将任务对象转换为 非挂起状态，
// 加锁进行操作，是为了与 get_task() 内的操作保持队列的同步
{
// 标识当前不可提取待执行的任务对象，迫使 get_task() 内部迅速解锁
m_xst_get_task.fetch_add(1);
m_lock_run_task.lock();
xtask_ptr->set_running_flag(false);
m_lock_run_task.unlock();
m_xst_get_task.fetch_sub(1);
}
......
}
......
};
我们可通过重载 x_task_t 所提供的两个扩展接口：is_suspend() 和 set_running_flag() 进行状态切换（即在调用 set_running_flag() 时让相关任务切换 is_suspend() 挂起/非挂起 两种状态），就可实现顺序执行。
示例代码如下所示：
#include "xthreadpool.h"
#include <chrono>
#include <string>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
////////////////////////////////////////////////////////////////////////////////
class x_order_task_t;
/**
* @class objectT
* @brief 产生 x_order_task_t 任务对象序列的测试类。
*/
class objectT
{
// constructor/destructor
public:
objectT(const std::string & xstr_name)
: m_xrunning_flag(false)
, m_seqno_taskid(0)
, m_xstr_name(xstr_name)
{
}
// public interfaces
public:
inline void set_running(bool xrunning_flag)
{
m_xrunning_flag = xrunning_flag;
}
inline bool is_running(void) const
{
return m_xrunning_flag;
}
inline const std::string & name(void) const
{
return m_xstr_name;
}
x_order_task_t * new_task(void);
// data members
private:
bool m_xrunning_flag;
int m_seqno_taskid;
std::string m_xstr_name;
};
/**
* @class x_order_task_t
* @brief 保证顺序执行的测试任务对象。
*/
class x_order_task_t : public x_threadpool_t::x_task_t
{
// constructor/destructor
public:
x_order_task_t(objectT * obj_owner, int taskid)
: m_obj_owner(obj_owner)
, m_taskid(taskid)
{
}
virtual ~x_order_task_t(void) { }
// overrides
public:
virtual void run(x_running_checker_t * xchecker_ptr) override
{
printf("%s:%02d\n", m_obj_owner->name().c_str(), m_taskid);
}
virtual bool is_suspend(void) const override
{
return m_obj_owner->is_running();
}
virtual void set_running_flag(bool xrunning_flag) override
{
m_obj_owner->set_running(xrunning_flag);
}
// data members
private:
objectT * m_obj_owner;
int m_taskid;
};
x_order_task_t * objectT::new_task(void)
{
return (new x_order_task_t(this, m_seqno_taskid++));
}
//====================================================================
int main(int argc, char * argv[])
{
// 线程池对象
x_threadpool_t xht_pool;
// 启动线程池
if (!xht_pool.startup(0, true))
{
printf("startup return false!\n");
return -1;
}
//======================================
// 便于测试而增加的代码
// 提交任务对象 : 使线程池的所有工作线程处于暂停状态
bool is_pause_pool = true;
for (int iter = 0, nthds = (int)xht_pool.size(); iter < nthds + 1; ++iter)
{
xht_pool.submit_task_ex(
[&is_pause_pool]() -> void
{
while (is_pause_pool)
{
std::this_thread::sleep_for(std::chrono::milliseconds(1));
}
});
}
//======================================
// 提交任务对象 : 按提交顺序执行任务对象
srand(time(NULL));
objectT objA("objA");
objectT objB("objB");
for (int iter = 0; iter < 100; ++iter)
{
if (0 == (rand() % 2))
{
xht_pool.submit_task(objA.new_task());
}
else
{
xht_pool.submit_task(objB.new_task());
}
}
// 使线程池开始工作（便于测试而增加的代码）
is_pause_pool = false;
//======================================
// 等待所有任务执行完成
while (xht_pool.task_count() > 0)
std::this_thread::sleep_for(std::chrono::milliseconds(1));
// 关闭线程池
xht_pool.shutdown();
return 0;
}
看一下测试的输出结果：
objA:00
objB:00
objB:01
objB:02
objB:03
objB:04
objA:01
objA:02
objA:03
objB:05
objA:04
objB:06
objB:07
objB:08
objB:09
objA:05
objA:06
objB:10
objB:11
objB:12
objA:07
objA:08
objA:09
objA:10
objB:13
objA:11
objA:12
objB:14
objB:15
objB:16
objB:17
objB:18
objB:19
objA:13
objA:14
objA:15
objA:16
objA:17
objA:18
objA:19
objB:20
objA:20
objA:21
objA:22
objB:21
objB:22
objB:23
objA:23
objB:24
objA:24
objB:25
objB:26
objB:27
objB:28
objB:29
objA:25
objB:30
objA:26
objA:27
objB:31
objB:32
objB:33
objA:28
objA:29
objA:30
objB:34
objA:31
objA:32
objB:35
objA:33
objA:34
objB:36
objA:35
objA:36
objB:37
objA:37
objA:38
objA:39
objA:40
objB:38
objB:39
objB:40
objA:41
objA:42
objA:43
objA:44
objA:45
objB:41
objA:46
objA:47
objA:48
objB:42
objA:49
objB:43
objA:50
objA:51
objA:52
objA:53
objA:54
objB:44
经检测，这已经达到我们所期望的结果。
