Linux网络编程——线程池架构

线程池概念及用途

• 概念：实质就是一个装着线程的的容器，线程池一种多线程的处理方式，处理过程间任务添加到队列，然后创建线程后自动启动这些任务。

• 比喻：这有点像去街上借的共享充电宝，收集这些充电宝的盒子就是线程池，充电宝就是线程。每个人去拿共享充电宝，就相当于是充电宝接任务。从这个比喻可以知道，共享充电宝收集盒（线程池）里面要先有一些充电宝（已经创建好的线程）才行。

• 为什么要有线程池：节省资源，每次来一个客户端都要创建、销毁、运行，这会消耗大量资源（因为创建和销毁会占用时间）。如果提前创建好一堆线程，那么就节省了创建和销毁的是时间。

• 线程池用途：在服务器有客户端接入的时候就会创建线程（来一个客户端创一个），而线程池就是管理这些线程的。
  

模型机制

任务队列的任务会交给线程池的线程来处理。这当中主要运用到的是信号量和条件变量来实现线程的阻塞和接任务。下面我分成了三部分：服务器（任务队列）、客户端、线程池。

当任务队列不为空，且没有满的时候：

• 在服务器（任务队列）和任务池两个之间，服务器充当生产者，任务池充当消费者。
• 在客户端和服务器（任务队列）间，客户端充当生产者，服务器（任务队列）充当消费者。

当任务队列的任务超出以建好线程数量时：再创建出多个线程。

示例代码

下面是代码书写时候的主要流程，和具体的操作

main文件
主要作用：创建线程池，接受客户端的申请，每个客户端接入就往任务列表中加入一个任务。

#include "threadpool.h"
#include 
#include 
#include 

//每个客户端创建出来的任务
void* mytask(void *arg)
{
	 printf("thread 0x%x is working on task %d\n", (int)pthread_self(), *(int*)arg);
	 sleep(1);
	 free(arg);
	 return NULL;
}
int main(void)
{
 	//建立一个线程池
 	threadpool_t *pool;
    	threadpool_init(&pool, 10); //线程上限最多10个
    	
    	//这里使用i来模拟客户端的请求接入
    	int i;
 	for (i=0; i<10; i++)
 	{
  		int *arg = (int *)malloc(sizeof(int));
  		*arg = i;
  		//给任务队列添加任务，该任务为mytask（在main函数上面），arg是传到mytask中的参数
  		threadpool_add_task(pool, mytask, arg);
 	}
 	
	//sleep(15);
	 threadpool_destroy(pool);
	 
	 return 0;
}	

condition.h和condition.c文件
作用：这两个文件只要是提供条件变量和互斥锁的使用方法。

condition.h文件

#ifndef _CONDITION_H_
#define _CONDITION_H_

#include 

//定义一个专门储藏互斥锁和条件变量的结构体
typedef struct condition
{
 	pthread_mutex_t pmutex;
 	pthread_cond_t pcond;
} condition_t;
//结构体初始化
int condition_init(condition_t *cond);

//互斥锁上所
int condition_lock(condition_t *cond);

//互斥锁解锁
int condition_unlock(condition_t *cond);

//条件变量等待
int condition_wait(condition_t *cond);

//条件变量轮询等待
int condition_timedwait(condition_t *cond, const struct timespec *abstime);

//条件变量唤醒
int condition_signal(condition_t *cond);

//条件变量广播（全部唤醒）
int condition_broadcast(condition_t *cond);

//条件变量和互斥量销毁
int condition_destroy(condition_t *cond);
#endif /* _CONDITION_H_ */

condition.c文件

#include "condition.h" 

//互斥锁、条件变量初始化
int condition_init(condition_t *cond)
{
	int status;
 	if ((status = pthread_mutex_init(&cond->pmutex, NULL)))
  		return status;
  	if ((status = pthread_cond_init(&cond->pcond, NULL)))
  		return status;
  	return 0;
}

//互斥锁加锁
int condition_lock(condition_t *cond)
{
 	return pthread_mutex_lock(&cond->pmutex); 
}

//互斥锁解锁
int condition_unlock(condition_t *cond)
{
 	return pthread_mutex_unlock(&cond->pmutex);
}

//条件变量等待
int condition_wait(condition_t *cond)
{
 	return pthread_cond_wait(&cond->pcond, &cond->pmutex);
}

//条件变量轮询等待
int condition_timedwait(condition_t *cond, const struct timespec *abstime)
{
 	return pthread_cond_timedwait(&cond->pcond, &cond->pmutex, abstime);
}

//条件变量唤醒
int condition_signal(condition_t *cond)
{
 	return pthread_cond_signal(&cond->pcond);
}

//条件变量和互斥锁销毁
int condition_destroy(condition_t* cond)
{
	int status;
 	if ((status = pthread_mutex_destroy(&cond->pmutex)))
  		return status;
  	if ((status = pthread_cond_destroy(&cond->pcond)))
  		return status;
  	return 0;
}

threadpool.c和threadpool.h文件
作用：实现线程池里面的线程和任务队列的连接工作，还有一些于线程初始化、销毁相关的函数。

threadpool.h文件

#ifndef _THREAD_POOL_H_
#define _THREAD_POOL_H_

#include "condition.h"

// 任务结构体,将任务放入队列由线程池中的线程来执行
typedef struct task
{
 	void *(*run)(void *arg); // 任务回调函数
 	void *arg;     // 回调函数参数
 	struct task *next;   // 链表队列
} task_t;

// 线程池结构体
typedef struct threadpool
{
 	condition_t ready;  	//任务准备就绪或者线程池销毁通知，这个结构体在条件变量类中
 	task_t *first;   	//任务队列头指针
 	task_t *last;   	//任务队列尾指针
 	int counter;   		//线程池中当前线程数
 	int idle;    		//线程池中当前正在等待任务的线程数
 	int max_threads;  	//线程池中最大允许的线程数
 	int quit;    		//销毁线程池的时候置1
} threadpool_t;

// 初始化线程池
void threadpool_init(threadpool_t **pool, int threads);

// 往线程池中添加任务
void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg);

// 销毁线程池
void threadpool_destroy(threadpool_t *pool);
#endif /* _THREAD_POOL_H_ */

threadpool.c文件

#include "threadpool.h"
#include 
#include 
#include 
#include 
#include 
#include 
void *thread_routine(void *arg)
{
 	struct timespec abstime;
 	threadpool_t *pool = (threadpool_t *)arg;
 	printf("thread 0x%x is starting\n", (int)pthread_self());
 	
 	//1. 设置为自分离线程
 	pthread_detach(pthread_self());

	//3. 进入轮询工作模式，如果不退出且队列不为空则一直工作
 	while(1)
 	{
 		//1. 先去看下有没有任务，有任务则处理任务，没有再wait
  		condition_lock(&pool->ready);
  		printf("thread 0x%x is working\n", (int)pthread_self());
  		if(pool->first != NULL) //这代表任务队列有任务
  		{
   			//把队列的第一个任务拿走，然后原本的第二个任务变成第一个任务
   			task_t *t = pool->first;  //取出第一个任务
   			pool->first = t->next;    //修改队列头
   			condition_unlock(&pool->ready); //先解锁，提高效率
   			//处理任务
   			t->run(t->arg);
   			free(t);
   			continue; //既然本次有任务，可能下次还有任务，则继续查看是否有任务
  		}
  		else
  		{
   			//没有任务，把互斥锁解锁，继续等待
   			condition_unlock(&pool->ready);
  		}

		if(pool->quit)
  		{
   			break;
  		}

		//2. 如果没有任务，则等待
  		printf("thread 0x%x is waiting\n", (int)pthread_self());
  		while(1)
  		{
   			//设置轮询时间
   			clock_gettime(CLOCK_REALTIME, &abstime);
   			abstime.tv_sec += 2; //延时2s  
   			
   			//condition_wait(&pool->ready);  //使用条件变量的等待也可以
   			condition_lock(&pool->ready);
			
			//线程没有接到任务，线程池中正在等待的线程数+1
  			pool->idle++;
  			
  			//轮询条件变量（轮询任务队列里面有没有新的任务）
   			int status = condition_timedwait(&pool->ready, &abstime);
   			condition_unlock(&pool->ready);
   			
   			if (status != ETIMEDOUT || pool->quit)
   			{
    				printf("thread 0x%x 线程被唤醒了\n", (int)pthread_self());
    				break; //注意：跳出当前循环，进入外面的while中，而不是跳到THREAD_EXIT
   			}
		   	else
		   	{
		    		printf("thread 0x%x 等待时间超过了\n", (int)pthread_self());
		    		//限定当前线程数为3个，超过的关闭。因为没那么多的任务，线程可以不用那么多了
		    		if(pool->counter >= 3)
		    		{
		     			goto THREAD_EXIT;
		    		}
		   	}
		}//最里层while结束
	}//最外层while结束
THREAD_EXIT: 
 	printf("thread 0x%x 退出\n", (int)pthread_self());
 	condition_lock(&pool->ready);
 	pool->counter--;
 	condition_unlock(&pool->ready);
 	pthread_exit(NULL); //退出线程
}

//初始化线程池结构体
void threadpool_init(threadpool_t **pool, int threads)
{
 	//1. 初始化基本的线程池参数
 	int i;
 	threadpool_t *newpool = malloc(sizeof(threadpool_t));

	*pool = newpool;
 	newpool->max_threads = threads; //最大的线程数不能
 	newpool->quit = 0;    //销毁线程池的时候置1
 	newpool->idle = 0;     //线程池中当前正在等待任务的线程数
 	newpool->first = NULL;   //任务队列头指针
 	newpool->last = NULL;   //任务队列尾指针
 	newpool->counter = 0;   //线程池中当前线程数
 	condition_init(&newpool->ready);//条件变量类里面的函数，创建一个条件变量
	
	//2. 默认有线程数，则在初始化的时候同时初始化N个线程
#if 1 
 	for(i= 0; i < threads; i++)
 	{
  		pthread_t tid;
  		if(pthread_create(&tid, NULL, thread_routine, newpool) == 0)//where is task?
  		{
   			condition_lock(&newpool->ready);
   			newpool->counter++;
   			condition_unlock(&newpool->ready);
  		}
 	}
#endif
}

void threadpool_add_task(threadpool_t *pool, void *(*run)(void *arg), void *arg)
{
 	if(pool->quit)
  		return;
  	
  	//1. 生成任务包
 	task_t *task = malloc(sizeof(task_t));
 	task->run = run;
 	task->arg = arg;

	//2. 加到task队列， 先上锁，再添加，再解锁
 	printf("Add new task %p ! \n", task);
 	condition_lock(&pool->ready);
 	if(pool->last == NULL) //if这里是在队列一次进来的时候执行的（队列里什么都没有的时候）
 	{
 		pool->last = task; //队列头
  		pool->first = pool->last; //初始化头
 	}
 	else
 	{
  		pool->last->next = task; // add
  		pool->last = task;
 	}

	//3. 计算一下线程数是否满足任务处理速度，不满足则创建一批
 	if(pool->counter < pool->max_threads && pool->idle <= 0) //当前线程数<最大线程数，且空闲线<=0
 	{
  		//？？线程创建策略，根据实际环境选择
  		// 策略1： 固定增长，每次增长??
  		// 策略2： 指数增长，每次翻倍?? 也就是创建 pool->counter
  		// 策略3： 线下增长，每次+1
  		//  策略4： 根据任务数量增长
	
		pthread_t tid;
		if(pthread_create(&tid, NULL, thread_routine, pool) == 0) //创建出来的线程，有任务就去接任务，没任务就轮询任务列表，等待被唤醒去接任务
  		{
   			pool->counter++;
  		}
  	}
  	//4. 通知线程去取任务处理
 	if(pool->idle > 0)
 	{
  		condition_signal(&pool->ready); //唤醒一个线程去处理任务
 	}

	//5. 解锁
 	condition_unlock(&pool->ready);
}

void threadpool_destroy(threadpool_t *pool)
{
 	//1. 设置退出条件
	pool->quit = 1;

	//2. 等待所有线程退出
 	while(pool->counter > 0)
 	{
  		//3. 广播，通知所有线程退出
  		condition_lock(&pool->ready);
  		condition_broadcast(&pool->ready); //唤醒所有线程退出
  		condition_unlock(&pool->ready);
  		sleep(1);
 	}
 	//4. 销毁线程池对象
 	free(pool);
}