线程池的原理及其在Windows/Linux下的实现

最新推荐文章于 2020-08-17 20:26:07 发布

ChaosMeta博客

最新推荐文章于 2020-08-17 20:26:07 发布

阅读量334

点赞数

分类专栏：校招知识点

本文链接：https://blog.csdn.net/qq_35703848/article/details/79713186

版权

校招知识点专栏收录该内容

16 篇文章 2 订阅

订阅专栏

1.为什么需要线程池
目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器等都具有一个共同点，就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。传统多线程方案中我们采用的服务器模型则是一旦接受到请求之后，即创建一个新的线程，由该线程执行任务。任务执行完毕后，线程退出，这就是是“即时创建，即时销毁”的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如果提交给线程的任务是执行时间较短，而且执行次数极其频繁，那么服务器将处于不停的创建线程，销毁线程的状态。我们将传统方案中的线程执行过程分为三个过程：T1、T2、T3。
T1：线程创建时间
T2：线程执行时间，包括线程的同步等时间
T3：线程销毁时间
那么我们可以看出，线程本身的开销所占的比例为(T1+T3) / (T1+T2+T3)。如果线程执行的时间很短的话，这比开销可能占到20%-50%左右。如果任务执行时间很频繁的话，这笔开销将是不可忽略的。除此之外，线程池能够减少创建的线程个数。通常线程池所允许的并发线程是有上界的，如果同时需要并发的线程数超过上界，那么一部分线程将会等待。而传统方案中，如果同时请求数目为2000，那么最坏情况下，系统可能需要产生2000个线程。尽管这不是一个很大的数目，但是也有部分机器可能达不到这种要求。
因此线程池的出现正是着眼于减少线程池本身带来的开销。线程池采用预创建的技术，在应用程序启动之后，将立即创建一定数量的线程(N1)，放入空闲队列中。这些线程都是处于阻塞（Suspended）状态，不消耗CPU，但占用较小的内存空间。当任务到来后，缓冲池选择一个空闲线程，把任务传入此线程中运行。当N1个线程都在处理任务后，缓冲池自动创建一定数量的新线程，用于处理更多的任务。在任务执行完毕后线程也不退出，而是继续保持在池中等待下一次的任务。当系统比较空闲时，大部分线程都一直处于暂停状态，线程池自动销毁一部分线程，回收系统资源。基于这种预创建技术，线程池将线程创建和销毁本身所带来的开销分摊到了各个具体的任务上，执行次数越多，每个任务所分担到的线程本身开销则越小，不过我们另外可能需要考虑进去线程之间同步所带来的开销。
2.一般线程池都必须具备下面几个组成部分：
线程池管理器:用于创建并管理线程池
工作线程: 线程池中实际执行的线程
任务接口: 尽管线程池大多数情况下是用来支持网络服务器，但是我们将线程执行的任务抽象出来，形成任务接口，从而是的线程池与具体的任务无关。

任务队列:线程池的概念具体到实现则可能是队列，链表之类的数据结构，其中保存执行线程。

3.在windows下C++实现代码如下：

lock.h

class CMyLock
{
public:
	CMyLock(){InitializeCriticalSection(&m_cs);}
	~CMyLock(){DeleteCriticalSection(&m_cs);}
	void Lock()
	{
		EnterCriticalSection(&m_cs);
	}
	void UnLock()
	{
		LeaveCriticalSection(&m_cs);
	}
private:
	CRITICAL_SECTION m_cs;
};


class CAutoLock
{
public:
	CAutoLock(CMyLock& mylock):m_lock(mylock)
	{
		m_lock.Lock();
	}
	~CAutoLock()
	{
		m_lock.UnLock();
	}
private:
	CMyLock& m_lock;
};

MyQueue.h

#include "lock.h"

template <class T>
class MyQueue
{
public:
	MyQueue():m_lWritePos(0),m_lReadPos(0),m_lLen(0)
	{}
	~MyQueue()
	{}
	//1.初始化环形缓冲区
	bool InitQueue(int nlen)
	{
		if(nlen <=0)
		{
			return false;
		}
		m_lLen = nlen;
		m_queue = new T*[nlen];

		//初始化数组
		memset(m_queue,0,nlen*sizeof(T));
	
		return true;
	}
	//2.释放缓冲区
	void UnInitQueue()
	{
		for(long i = 0; i< m_lLen;i++)
		{
			if(m_queue[i])
			{
				delete m_queue[i];
				m_queue[i] = NULL;
			}
		}

		delete []m_queue;

	}
	//3.投递数据
	bool push(T* pnode)
	{
		CAutoLock lock(m_WriteLock);
		if(NULL != m_queue[m_lWritePos] )
		{
			return false;
		}
		m_queue[m_lWritePos] = pnode;
		m_lWritePos = (m_lWritePos + 1)%m_lLen;

		return true;
	}

	//4.取出数据
	bool pop(T*& pnode)
	{
		CAutoLock lock(m_ReadLock);
		if(NULL == m_queue[m_lReadPos] )
		{
			return false;
		}
		pnode = m_queue[m_lReadPos];
		m_queue[m_lReadPos] = NULL;
		m_lReadPos = (m_lReadPos + 1)%m_lLen;
		return true;
	}

private:
	T** m_queue;
	long m_lWritePos;
	long m_lReadPos;
	long m_lLen;
	CMyLock m_ReadLock;
	CMyLock m_WriteLock;
};

ThreadPool.h

#pragma once
#include <list>
#include <queue>
#include <Windows.h>
#include "MyQueue.h"
using namespace std;
class Itask
{
public:
	Itask(){}
	virtual ~Itask(){}
	virtual void RunTask() = 0;


};




class ThreadPool
{
public:
	ThreadPool(void);
	~ThreadPool(void);
public:
	//1.创建线程池
	bool CreateThreadPool(long lMinThreadNum,long lMaxThreadNum,long lMaxItaskCount = 100);
	//2.销毁线程池
	void DestroyThreadPool();
	//3.投递任务
	bool PushItask(Itask *pItask);

	//4.线程函数
	 static  unsigned _stdcall ThreadProc( void * );

	 void ThreadProc();

private:
	list<HANDLE > m_lstThread; //记录线程的链表
	bool   m_bflagQuit;//退出标识
	HANDLE m_hSemphore; //通知线程干活的信号
	//queue<Itask*> m_qItask; //装任务的队列
	long m_lRunThreadNum; //运行的线程个数
	long m_lCreateThreadNum; //创建的线程个数
	long m_lMaxThreadNum; //最大的线程个数
	//CMyLock m_Lock;
	MyQueue<Itask> m_qItask;
};

ThreadPool.cpp

#include "ThreadPool.h"
#include <process.h>


ThreadPool::ThreadPool(void)
{
	m_bflagQuit = false;
	m_hSemphore = NULL;
	m_lRunThreadNum = 0;
	m_lCreateThreadNum = 0;
	m_lMaxThreadNum = 0;
}


ThreadPool::~ThreadPool(void)
{
	DestroyThreadPool();
}


bool ThreadPool::CreateThreadPool(long lMinThreadNum,long lMaxThreadNum,long lMaxItaskCount)
{
	HANDLE hthread;
	//校验参数
	if(lMinThreadNum <= 0 ||lMaxThreadNum <=0 ||lMinThreadNum> lMaxThreadNum || lMaxItaskCount <=0)
	{
		return false;
	}

	//初始化退出变量
	m_bflagQuit = true;
	//初始化队列
	if(!m_qItask.InitQueue(lMaxItaskCount))
	{
		return false;
	}
	m_hSemphore = CreateSemaphore(NULL,0,lMaxThreadNum,NULL);
	//创建线程
	for(int i = 0; i <lMinThreadNum;i++ )
	{
		hthread = (HANDLE) _beginthreadex(0,0,&ThreadPool::ThreadProc,this,0,0);
		if( NULL == hthread)continue;
		m_lstThread.push_back(hthread);
	}
	m_lCreateThreadNum = lMinThreadNum;
	m_lMaxThreadNum = lMaxThreadNum;
	return true;
}

unsigned _stdcall ThreadPool::ThreadProc( void * lpvoid)
{
	ThreadPool *pthis = (ThreadPool *)lpvoid;

	pthis->ThreadProc();
	return 0;
}

bool ThreadPool::PushItask(Itask *pItask)
{
	//1.校验参数
	if(NULL  == pItask )return false;

	//2.将任务加入到队列
	/*{
		CAutoLock lock(m_Lock);
		m_qItask.push(pItask);
	}*/

	while(!m_qItask.push(pItask))
	{
		Sleep(1);
	}

	

	//3.释放信号量 //如果有空闲的服务员
	if(m_lRunThreadNum < m_lCreateThreadNum)
	{
		ReleaseSemaphore(m_hSemphore,1,NULL);
	}
	else if(m_lCreateThreadNum   < m_lMaxThreadNum) //如果没有空闲服务员，并且有空地
	{
		HANDLE	hthread = (HANDLE) _beginthreadex(0,0,&ThreadPool::ThreadProc,this,0,0);
		 if( NULL == hthread)return false;
		 ReleaseSemaphore(m_hSemphore,1,NULL);
		 m_lstThread.push_back(hthread);
		 m_lCreateThreadNum++;
	}
	else  //满员啦
	{
		//等待
	}
	

	return true;
}

void ThreadPool::ThreadProc()
{
	Itask *pitask = NULL;
	while(m_bflagQuit)
	{
		//等待任务--信号量
		WaitForSingleObject(m_hSemphore,INFINITE);

		//将线程从睡眠状态切换到工作状态
		//m_lRunThreadNum++;
		InterlockedIncrement(&m_lRunThreadNum);

		//从队列中取任务

		while(m_qItask.pop(pitask))
		{
			//执行任务
			pitask->RunTask();
			delete pitask;
			pitask = NULL;
		}
		while(!m_qItask.empty())
		{
			{
				CAutoLock lock(m_Lock);
				if(m_qItask.empty())
				{
					break;
				}
			    pitask = m_qItask.front();
			    m_qItask.pop();
			}

			//执行任务
			pitask->RunTask();
			delete pitask;
			pitask = NULL;
		}
		

		//将线程从工作状态切换到睡眠状态
		//m_lRunThreadNum--;
		InterlockedDecrement(&m_lRunThreadNum);


	}

}
	//2.销毁线程池
void ThreadPool::DestroyThreadPool()
{
	//结束线程
	m_bflagQuit = false;

	//检查线程是否退出，如果不能退出，则强制杀死
	list<HANDLE>::iterator lstTHreadite = m_lstThread.begin();
	while(lstTHreadite != m_lstThread.end())
	{
		if(WAIT_TIMEOUT == WaitForSingleObject(*lstTHreadite,100))
		{
			TerminateThread(*lstTHreadite,-1);
		}
		CloseHandle(*lstTHreadite);
		*lstTHreadite = NULL;
		lstTHreadite++;
	}
	//判断队列中是否有任务，如果有则删除
	for()
	{
	}
	//清空链表
	m_lstThread.clear();

	m_qItask.UnInitQueue();

}

3.在Linux下C实现代码如下：

thread_pool.h

#ifndef __THREAD_POOL_H__
#define __THREAD_POOL_H__

#include <pthread.h>

 /*********************************************************************
* 任务回调函数，也可根据需要自行修改
*********************************************************************/
typedef void *(*pool_task_f)(void *arg);

/*********************************************************************
* 任务句柄
*********************************************************************/
typedef struct _task{
	pool_task_f process;/*回调函数，任务运行时会调用此函数，注意也可声明成其它形式*/
	void *arg;     /*回调函数的参数*/
	struct _task *next;
}pool_task;

/*********************************************************************
* 线程池句柄
*********************************************************************/
typedef struct
{
	pthread_t *threadid;		/* 线程号 */
	int threads_limit;			/* 线程池中允许的活动线程数目 */
	int destroy_flag;			/* 是否销毁线程池 , 0销毁，1不销毁*/
	pool_task *queue_head;	/* 链表结构，线程池中所有等待任务 */
	int task_in_queue;			/* 当前等待队列的任务数目 */
	pthread_mutex_t queue_lock;	/* 锁 */
	pthread_cond_t queue_ready;	/* 条件变量 */
}pool_t;

/******************************************** *
*参数:		
			pool：线程池句柄
			threads_limit：线程池中线程的数量
*返回值:	无
*********************************************************************/
void pool_init(pool_t *pool, int threads_limit);

/*********************************************************************
*功能:		销毁线程池，等待队列中的任务不会再被执行，
			但是正在运行的线程会一直,把任务运行完后再退出
*参数:		线程池句柄
*返回值:	成功：0，失败非0
********************************************************************/
int pool_uninit(pool_t *pool);

/*********************************************************************
*功能:		向线程池中添加一个任务
*参数:		
			pool：线程池句柄
			process：任务处理函数
			arg：任务参数
*返回值:	0
*********************************************************************/
int pool_add_task(pool_t *pool, pool_task_f process, void *arg);


#endif

thread_pool.c

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>

#include "thread_pool.h"

static void *pool_thread_server(void *arg);

/*********************************************************************
*功能:		初始化线程池结构体并创建线程
*参数:		
			pool：线程池句柄
			threads_limit：线程池中线程的数量
*返回值:	无
*********************************************************************/
void pool_init(pool_t *pool, int threads_limit)
{
	pool->threads_limit = threads_limit;
	pool->queue_head = NULL;
	pool->task_in_queue = 0;
	pool->destroy_flag = 0;
	/*创建存放线程ID的空间*/
	pool->threadid = (pthread_t *)calloc(threads_limit, sizeof(pthread_t));
	int i = 0;
	/*初始化互斥锁和条件变量*
	pthread_mutex_init(&(pool->queue_lock), NULL);
	pthread_cond_init(&(pool->queue_ready), NULL);
	/*循环创建threads_limit个线程*/
	for (i = 0; i < threads_limit; i++){
		pthread_create(&(pool->threadid[i]), NULL, pool_thread_server, pool);
	}
	return;
}

/********************************************************************
*功能:		销毁线程池，等待队列中的任务不会再被执行，
			但是正在运行的线程会一直,把任务运行完后再退出
*参数:		线程池句柄
*返回值:	成功：0，失败非0
*********************************************************************/
int pool_uninit(pool_t *pool)
{
	pool_task *head = NULL;
	int i;
	
	pthread_mutex_lock(&(pool->queue_lock));
	if(pool->destroy_flag)/* 防止两次调用 */
		return -1;
	pool->destroy_flag = 1;
	pthread_mutex_unlock(&(pool->queue_lock));
	/* 唤醒所有等待线程，线程池要销毁了 */
	pthread_cond_broadcast(&(pool->queue_ready));
	/* 阻塞等待线程退出，否则就成僵尸了 */
	for (i = 0; i < pool->threads_limit; i++)
		pthread_join(pool->threadid[i], NULL);
	free(pool->threadid);
	/* 销毁等待队列 */
	pthread_mutex_lock(&(pool->queue_lock));
	while(pool->queue_head != NULL){
		head
		= pool->queue_head;
		pool->queue_head = pool->queue_head->next;
		free(head);
	}
	pthread_mutex_unlock(&(pool->queue_lock));
	/*条件变量和互斥量也别忘了销毁*/
	pthread_mutex_destroy(&(pool->queue_lock));
	pthread_cond_destroy(&(pool->queue_ready));
	return 0;
}

/*********************************************************************
*功能:		向任务队列中添加一个任务
*参数:		
			pool：线程池句柄
			process：任务处理函数
			arg：任务参数
*返回值:	无
*********************************************************************/
static void enqueue_task(pool_t *pool, pool_task_f process, void *arg)
{
	pool_task *task = NULL;
	pool_task *member = NULL;
	
	pthread_mutex_lock(&(pool->queue_lock));
	
	if(pool->task_in_queue >= pool->threads_limit){
		printf("task_in_queue > threads_limit!\n");
		pthread_mutex_unlock (&(pool->queue_lock));
		return;
	}
	

	task = (pool_task *)calloc(1, sizeof(pool_task));
	assert(task != NULL);
	task->process = process;
	task->arg = arg;
	task->next = NULL;
	pool->task_in_queue++;
	member = pool->queue_head;
	if(member != NULL){
		while(member->next != NULL)	/* 将任务加入到任务链连的最后位置. */
			member = member->next;
		member->next = task;
	}else{
		pool->queue_head = task;	/* 如果是第一个任务的话,就指向头 */
	}
	printf("\ttasks %d\n", pool->task_in_queue);
	/* 等待队列中有任务了，唤醒一个等待线程 */
	pthread_cond_signal (&(pool->queue_ready));
	pthread_mutex_unlock (&(pool->queue_lock));
}

/*********************************************************************
*功能:		从任务队列中取出一个任务
*参数:		线程池句柄
*返回值:	任务句柄
*********************************************************************/
static pool_task *dequeue_task(pool_t *pool)
{
	pool_task *task = NULL;
	
	pthread_mutex_lock(&(pool->queue_lock));
	/* 判断线程池是否要销毁了 */
	if(pool->destroy_flag){
	{
		pthread_mutex_unlock(&(pool->queue_lock));
		printf("thread 0x%lx will be destroyed\n", pthread_self());
		pthread_exit(NULL);
	}
	/* 如果等待队列为0并且不销毁线程池，则处于阻塞状态 */
	if(pool->task_in_queue == 0){
		while((pool->task_in_queue == 0) && (!pool->destroy_flag)){
			printf("thread 0x%lx is leisure\n", pthread_self());
			/* 注意:pthread_cond_wait是一个原子操作，等待前会解锁，唤醒后会加锁 */
			pthread_cond_wait(&(pool->queue_ready), &(pool->queue_lock));
		}
	}else{
		/* 等待队列长度减去1，并取出队列中的第一个元素 */
		pool->task_in_queue--;
		task = pool->queue_head;
		pool->queue_head = task->next;
		printf("thread 0x%lx received a task\n", pthread_self());
	}
	pthread_mutex_unlock(&(pool->queue_lock));
	return task;
}

/*********************************************************************
*功能:		向线程池中添加一个任务
*参数:		
			pool：线程池句柄
			process：任务处理函数
			arg：任务参数
*返回值:	0
*********************************************************************/
int pool_add_task(pool_t *pool, pool_task_f process, void *arg)
{
	enqueue_task(pool, process, arg);
	return 0;
}

/*********************************************************************
*功能:		线程池服务程序
*参数:		略poo  
*返回值:	略
*********************************************************************/
static void *pool_thread_server(void *arg)
{
	pool_t *pool = NULL;
	
	pool = (pool_t *)arg;
	while(1){
		pool_task *task = NULL;
		task = dequeue_task(pool);
		/*调用回调函数，执行任务*/
		if(task != NULL){
			printf ("thread 0x%lx is busy\n", pthread_self());
			task->process(task->arg);
			free(task);
			task = NULL;
		}
	}
	/*这一句应该是不可达的*/
	pthread_exit(NULL);	 
	return NULL;
}

mian.c

#include <stdio.h>
#include <unistd.h>

#include "thread_pool.h"

void *task_test(void *arg)
{
	printf("\t\tworking on task %d\n", (int)arg);
	sleep(1);			/*休息一秒，延长任务的执行时间*/
	return NULL;
}

void thread_pool_demo(void)
{
	pool_t pool;
	int i = 0;

	pool_init(&pool, 2);//初始化一个线程池，其中创建2个线程
	sleep(1);
	for(i = 0; i < 5; i++){
		sleep(1);
		pool_add_task(&pool, task_test, (void *)i);//添加一个任务
	}
	sleep(4);

	pool_uninit(&pool);//删除线程池
}

int main (int argc, char *argv[])
{  
	thread_pool_demo();
	return 0;
}

ChaosMeta博客

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
线程池的原理及其在Windows/Linux下的实现

1.为什么需要线程池目前的大多数网络服务器，包括Web服务器、Email服务器以及数据库服务器等都具有一个共同点，就是单位时间内必须处理数目巨大的连接请求，但处理时间却相对较短。传统多线程方案中我们采用的服务器模型则是一旦接受到请求之后，即创建一个新的线程，由该线程执行任务。任务执行完毕后，线程退出，这就是是“即时创建，即时销毁”的策略。尽管与创建进程相比，创建线程的时间已经大大的缩短，但是如...
复制链接

扫一扫