线程池原理和简单实现

1. 为什么需要线程池

当我们的程序需要同时处理多个业务的时候，我们就需要使用多线程来进行编程。尤其界面程序，如果采用单线程，当点击UI控件后，如果事件处理函数耗费较长时间，就会照成UI卡死无法继续响应的情况。此外，如果程序需要不断地进行I/O操作等耗时操作时，也可以将其放入一个专门的线程中。

上述中我们谈到了线程的作用。线程是CPU调度程序的最小单元，CPU通过调度机制分配给每个线程时间片，从而让线程得以运行。假如我们需要动态地创建大量线程，并且线程所处理的任务耗时较少，就会照成一定的CPU资源浪费了，因为创建线程、销毁线程对于CPU来说也是一个不小的开支。这种场景下线程池就能发挥它的作用了。线程池的概念是事先创建一定数目的线程，并处在阻塞状态下，等待任务的到来；当任务到来时，线程池会释放一个信号量，某个线程就会抢到信号量并处理该任务。

下面我们就将实现一个简单的线程池，系统为Win10，IDE为VisualStudio2013。

2. 如何实现线程池

根据线程池的功能，我们可以创建三个类，任务类、线程池类、线程信息类。

线程池原理和简单实现

1）任务类AbstractTask

任务接口类，需要用户继承该类并实现run函数。

2）线程池类

负责线程的创建、任务的添加、信号的创建和控制、锁对象的创建和管理、线程池的销毁等任务。通过信号量来实现多线程之间的同步，并在多线程之间利用胡策锁来保护成员对象。

3）线程参数类

该类主要是作为创建线程时的参数，传递给线程处理函数，从而进行相应的处理。

u 需要注意的问题：

我们都知道，创建线程时需要指定线程处理函数，该函数必须时静态函数，而不能是类的非静态成员函数，所以ThreadPool类中定义为：

//线程处理函数

static voidThreadFunc(void* arg);

但同时我们也知道，在类的静态函数中不能“直接”调用类的非静态成员。那在线程池中我们又必须在静态函数中访问线程池中的非静态成员，这该如何办呢？你仔细想一想…

对，注意到arg参数了吗？创建线程时，将线程池的指针利用参数传入到静态函数中，从而就可以利用该线程池指针访问非静态成员了。你想到了吗？

其实在Win32编程中也会遇到相似的问题，当我们创建窗口类时，必须指定窗口处理函数，该函数同样必须是静态的。如果我们封装了一个窗口类，并且想在窗口处理函数中访问该类的非静态成员时，也可以将该窗口的指针通过参数传入到窗口处理函数中，从而达到我们的目的，学习要融会贯通哦！

----------------------------------------------------------------------------

-------------------------------代码实现------------------------------------------

<ThreadPool.h>

#pragma once
#include <Windows.h>
#include <list>
#include <vector>
using std::list;
using std::vector;

/* 前置声明 */
class Task;
class ThreadPara;//传递给线程的参数

class ThreadPool
{
public:
ThreadPool();
ThreadPool(int maxNum);
~ThreadPool();

//线程池初始化
void init();

//线程池销毁
void release();

//增加任务
void addTask(Task* task);

//线程主函数
static void ThreadFunc(void* arg);
private:
typedef list<Task*> TaskList;
TaskList m_taskList; //未处理的任务池
HANDLE m_mutexTaskList;//任务池锁
HANDLE m_semNewTask; //增加新任务信号
HANDLE m_semDoneTask; //完成任务信号

typedef vector<ThreadPara> ThreadList;
ThreadList m_threadList;//线程集合
HANDLE m_mutexThreadPools;//线程池锁
int m_threadNum;//线程数目

HANDLE m_semDestoryThreadPool;//线程池释放信号

bool isInit;//是否初始化
};

----------------------------------------------------------------------------------------

---------------------------------------------------------------------------------------

<ThreadPool.cpp>

#include "ThreadPool.h"
#include "ThreadPara.h"
#include "Task.h"
#include <errno.h>
#include <process.h>

ThreadPool::ThreadPool() :m_threadNum(10), isInit(false)
{
}

ThreadPool::ThreadPool(int maxNum){
m_threadNum = maxNum;
}

ThreadPool::~ThreadPool()
{
}

void ThreadPool::init(){
if (isInit){
return;
}
//创建信号量和锁对象
m_mutexTaskList = CreateMutex(NULL, FALSE, L"m_mutexTaskList");//如果是true，则当前线程已经获取该锁对象，一定要注意
m_mutexThreadPools = CreateMutex(NULL, FALSE, L"m_mutexThreadPools");

m_semNewTask = CreateSemaphore(NULL, 0, 100, L"m_semNewTask");
m_semDoneTask = CreateSemaphore(NULL, 0, 100, L"m_semDoneTask");
m_semDestoryThreadPool = CreateSemaphore(NULL, 0, 100, L"m_semDestoryThreadPool");

if (m_mutexTaskList == 0
  || m_mutexThreadPools == 0
  || m_semNewTask == 0
  || m_semDoneTask == 0
  || m_semDestoryThreadPool == 0){
  printf("Fatal Error:创建信号量和锁失败!\n");
  return;
}

//创建线程
m_threadList.reserve(m_threadNum);
for (int i = 0; i < m_threadNum; i++)
{
  ThreadPara thradPara;
  thradPara.id = i+1;
  thradPara.pool = this;
  thradPara.run = true;
  m_threadList.push_back(thradPara);

ThreadPara* para = &m_threadList[i];
m_threadList[i].hid = _beginthread(ThreadFunc, 0, (void*)para);
}
}

void ThreadPool::addTask(Task* task)
{
WaitForSingleObject(m_mutexTaskList, INFINITE);
m_taskList.push_back(task);
printf("add task%d\n", task->id);
ReleaseMutex(m_mutexTaskList);

//释放信号量
ReleaseSemaphore(m_semNewTask, 1, NULL);
}

void ThreadPool::ThreadFunc(void* arg){
//参数信息
ThreadPara* threadPara = (ThreadPara*)arg;
ThreadPool* pool = threadPara->pool;
printf("线程%d[%d]启动,pool=%x...\n", threadPara->id, threadPara->hid, pool);

//需要等待的信号
HANDLE hWaitHandle[2];
hWaitHandle[0] = pool->m_semDestoryThreadPool;
hWaitHandle[1] = pool->m_semNewTask;
while (threadPara->run)
{
  //等待信号
  DWORD val = WaitForMultipleObjects(2, hWaitHandle, false, INFINITE);

  if (val == WAIT_OBJECT_0){//线程池销毁
   printf("线程%d退出...\n", threadPara->id);
   break;
  }

  //处理新任务
  WaitForSingleObject(pool->m_mutexTaskList, INFINITE);
  Task* task = *pool->m_taskList.begin();
  pool->m_taskList.pop_front();
  ReleaseMutex(pool->m_mutexTaskList);
  task->run();
  delete task;
  //释放信号量
  //ReleaseSemaphore(pool->m_semDoneTask, 1, NULL);
}
}

void ThreadPool::release(){
ReleaseSemaphore(m_semDestoryThreadPool, m_threadNum, NULL);
m_threadList.clear();

for (TaskList::iterator iter = m_taskList.begin(); iter != m_taskList.end(); iter++){
delete *iter;
}
m_taskList.clear();

CloseHandle(m_mutexTaskList);
CloseHandle(m_mutexThreadPools);
CloseHandle(m_semDestoryThreadPool);
CloseHandle(m_semDoneTask);
CloseHandle(m_semNewTask);
}

---------------------------------------------------------------------------------------

<Task.h>

#pragma once
class Task
{
public:
Task(int id);
~Task();
virtual void run() = 0;

public:
int id;
};

---------------------------------------------------------------------------------------

<Task.cpp>

#include "Task.h"

Task::Task(int id)
{
this->id = id;
}

Task::~Task()
{
}

---------------------------------------------------------------------------------------

<ThreadPara.h>

#pragma once
class ThreadPool;
class ThreadPara{
public:
int id;//线程序号
int hid;//线程句柄号
bool run;//运行标志
ThreadPool* pool;//线程池
public:
ThreadPara():id(0), hid(0), run(false), pool(nullptr){}
~ThreadPara(){}
};

---------------------------------------------------------------------------------------

<Test.cpp>

#include"Task.h"
#include"ThreadPool.h"
#include<stdio.h>

class MyTask: public Task
{
public:
MyTask(int id):Task(id){}
~MyTask(){}

virtual void run(){ printf("Task %d run...\n", id); Sleep(100);}
};

void main(){
ThreadPool threadPool(10);
threadPool.init();
for (int i = 0; i < 20; i++){
Task* task = new MyTask(i+1);
threadPool.addTask(task);
}

Sleep(1000);
threadPool.release();
printf("release threadpool\n");
getchar();
}

线程池原理和简单实现

1. 为什么需要线程池

2. 如何实现线程池

相关推荐