【图书推荐】《Linux C与C++一线开发实践（第2版）》_linux c与c++一线开发实践pdf-CSDN博客
《Linux C与C++一线开发实践（第2版）（Linux技术丛书）》(朱文伟，李建英)【摘要 书评 试读】- 京东图书 (jd.com)
9.5.1 线程池的定义
这里的池是形象的说法。线程池就是有一堆已经创建好了的线程，初始都处于空闲等待状态，当有新的任务需要处理的时候，就从这堆线程（这堆线程比喻为线程池）中取一个空闲等待的线程来处理该任务，当任务处理完毕后，就把该线程放回池中（一般就是将线程状态置为空闲），以供后面的任务继续使用。当池子里的线程全都处于忙碌状态时，线程池中没有可用的空闲等待线程，此时可以根据需要选择创建一个新的线程并置入池中，或者通知任务当前线程池里所有线程都在忙，等待片刻再尝试。这个过程可以用图9-2来表示。
图9-2
9.5.2 使用线程池的原因
线程的创建和销毁相对于进程的创建和销毁来说是轻量级的（开销没有进程那么大），但是当我们的任务需要进行大量线程的创建和销毁操作时，这些开销合在一起就比较大了。比如，设计一个压力性能测试框架的时候，需要连续产生大量的并发操作。线程池在这种场合是非常适用的。线程池的好处就在于线程复用，某个线程在处理完一个任务后，可以继续处理下一个任务，而不用销毁后再创建，这样可以避免无谓的开销，因此尤其适用于连续产生大量并发任务的场合。
9.5.3 用C++实现一个简单的线程池
在知道了线程池的基本概念后，下面我们用Linux C++来实现一个基本的线程池，该线程池虽然简单，但可以体现线程池的基本工作思想。另外，线程池的实现是千变万化的，有时候要根据实际应用场合来定制，但万变不离其宗，原理都是一样的。现在我们从简单的、基本的线程池开始实践，为以后工作中设计复杂高效的线程池做准备。
【例9.9】用C++实现一个简单的线程池
（1）打开Visual Studio Code，新建文本文件并输入如下代码：
#ifndef __THREAD_POOL_H
#define __THREAD_POOL_H
#include <vector>
#include <string>
#include <pthread.h>
using namespace std;
/*执行任务的类：设置任务数据并执行*/
class CTask {
protected:
string m_strTaskName; // 任务的名称
void* m_ptrData; // 要执行的任务的具体数据
public:
CTask() = default;
CTask(string &taskName)
: m_strTaskName(taskName)
, m_ptrData(NULL) {}
virtual int Run() = 0;
void setData(void* data); // 设置任务数据
virtual ~CTask() {}
};
/*线程池管理类*/
class CThreadPool {
private:
static vector<CTask*> m_vecTaskList; // 任务列表
static bool shutdown; // 线程退出标志
int m_iThreadNum; // 线程池中启动的线程数
pthread_t *pthread_id;
static pthread_mutex_t m_pthreadMutex; // 线程同步锁
static pthread_cond_t m_pthreadCond; // 线程同步条件变量
protected:
static void* ThreadFunc(void *threadData); // 新线程的线程回调函数
static int MoveToIdle(pthread_t tid); // 线程执行结束后，把自己放入空闲线程中
static int MoveToBusy(pthread_t tid); // 移入到忙碌线程中去
int Create(); // 创建线程池中的线程
public:
CThreadPool(int threadNum);
int AddTask(CTask *task); // 把任务添加到任务队列中
int StopAll(); // 使线程池中的所有线程退出
int getTaskSize(); // 获取当前任务队列中的任务数
};
#endif
（2）保存代码为头文件thread_pool.h，再新建一个thread_pool.cpp文件，并输入如下代码：
#include "thread_pool.h"
#include <cstdio>
void CTask::setData(void* data) {
m_ptrData = data;
}
// 静态成员初始化
vector<CTask*> CThreadPool::m_vecTaskList;
bool CThreadPool::shutdown = false;
pthread_mutex_t CThreadPool::m_pthreadMutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t CThreadPool::m_pthreadCond = PTHREAD_COND_INITIALIZER;
// 线程管理类构造函数
CThreadPool::CThreadPool(int threadNum) {
this->m_iThreadNum = threadNum;
printf("I will create %d threads.\n", threadNum);
Create();
}
// 线程回调函数
void* CThreadPool::ThreadFunc(void* threadData) {
pthread_t tid = pthread_self();
while (1)
{
pthread_mutex_lock(&m_pthreadMutex);
// 如果队列为空，等待新任务进入任务队列
while (m_vecTaskList.size() == 0 && !shutdown)
pthread_cond_wait(&m_pthreadCond, &m_pthreadMutex);
// 关闭线程
if (shutdown)
{
pthread_mutex_unlock(&m_pthreadMutex);
printf("[tid: %lu]\texit\n", pthread_self());
pthread_exit(NULL);
}
printf("[tid: %lu]\trun: ", tid);
vector<CTask*>::iterator iter = m_vecTaskList.begin();
// 取出一个任务并处理
CTask* task = *iter;
if (iter != m_vecTaskList.end())
{
task = *iter;
m_vecTaskList.erase(iter);
}
pthread_mutex_unlock(&m_pthreadMutex);
task->Run(); // 执行任务
printf("[tid: %lu]\tidle\n", tid);
}
return (void*)0;
}
// 往任务队列里添加任务并发出线程同步信号
int CThreadPool::AddTask(CTask *task) {
pthread_mutex_lock(&m_pthreadMutex);
m_vecTaskList.push_back(task);
pthread_mutex_unlock(&m_pthreadMutex);
pthread_cond_signal(&m_pthreadCond);
return 0;
}
// 创建线程
int CThreadPool::Create() {
pthread_id = new pthread_t[m_iThreadNum];
for (int i = 0; i < m_iThreadNum; i++)
pthread_create(&pthread_id[i], NULL, ThreadFunc, NULL);
return 0;
}
// 停止所有线程
int CThreadPool::StopAll() {
// 避免重复调用
if (shutdown)
return -1;
printf("Now I will end all threads!\n\n");
// 唤醒所有等待线程，线程池也要销毁了
shutdown = true;
pthread_cond_broadcast(&m_pthreadCond);
// 清理僵尸线程
for (int i = 0; i < m_iThreadNum; i++)
pthread_join(pthread_id[i], NULL);
delete[] pthread_id;
pthread_id = NULL;
// 销毁互斥锁和条件变量
pthread_mutex_destroy(&m_pthreadMutex);
pthread_cond_destroy(&m_pthreadCond);
return 0;
}
// 获取当前队列中的任务数
int CThreadPool::getTaskSize() {
return m_vecTaskList.size();
}
（3）新建一个main.cpp，输入如下代码：
#include "thread_pool.h"
#include <cstdio>
#include <stdlib.h>
#include <unistd.h>
class CMyTask : public CTask {
public:
CMyTask() = default;
int Run() {
printf("%s\n", (char*)m_ptrData);
int x = rand() % 4 + 1;
sleep(x);
return 0;
}
~CMyTask() {}
};
int main() {
CMyTask taskObj;
char szTmp[] = "hello!";
taskObj.setData((void*)szTmp);
CThreadPool threadpool(5); // 线程池大小为5
for (int i = 0; i < 10; i++)
threadpool.AddTask(&taskObj);
while (1) {
printf("There are still %d tasks need to handle\n", threadpool.
getTaskSize());
// 任务队列里已经没有任务了
if (threadpool.getTaskSize() == 0) {
// 清除线程池
if (threadpool.StopAll() == -1) {
printf("Thread pool clear, exit.\n");
exit(0);
}
}
sleep(2);
printf("2 seconds later...\n");
}
return 0;
}
（4）把这3个文件上传到Linux，在命令行下编译并运行：
# g++ thread_pool.cpp test.cpp -o test -lpthread
# ./test
I will create 5 threads.
There are still 10 tasks need to handle
[tid: 139992529053440] run: hello!
[tid: 139992520660736] run: hello!
[tid: 139992512268032] run: hello!
[tid: 139992503875328] run: hello!
[tid: 139992495482624] run: hello!
2 seconds later...
There are still 5 tasks need to handle
[tid: 139992512268032] idle
[tid: 139992512268032] run: hello!
[tid: 139992495482624] idle
[tid: 139992495482624] run: hello!
[tid: 139992520660736] idle
[tid: 139992520660736] run: hello!
[tid: 139992529053440] idle
[tid: 139992529053440] run: hello!
[tid: 139992503875328] idle
[tid: 139992503875328] run: hello!
2 seconds later...
There are still 0 tasks need to handle
Now I will end all threads!
[tid: 139992520660736] idle
[tid: 139992520660736] exit
[tid: 139992495482624] idle
[tid: 139992495482624] exit
[tid: 139992512268032] idle
[tid: 139992512268032] exit
[tid: 139992529053440] idle
[tid: 139992529053440] exit
[tid: 139992503875328] idle
[tid: 139992503875328] exit
2 seconds later...
There are still 0 tasks need to handle
Thread pool clear, exit.
