Linux下线程池的实现

之前用epoll和进程池实现的简单的文件传输功能有一个缺点，就是没有排队功能。当进程池中所有进程都在工作，后到来的请求可能因为timing合适，正好有进程空闲，反而比先到的请求更早得到相应。为了实现“先请求客户端，优先服务”的功能，本文用进程池和任务队列实现了排队功能，让客户端遵从先到先得的顺序进行任务传输。

一、概念分析
线程池的实现类似于生产者消费者模型，首先需要定义一个线程池的结构体来控制线程的运行和终止；其次，要满足不同线程执行不同的任务，而且在程序执行过程中还可以动态加入任务的功能，还需要定义一个任务链表。 当有客户端发来任务请求时，将new_fd加入队列尾；当任务队列不为空且有空闲的线程时，线程从队列头取走一个任务。
我们使用链表实现队列。队列当有新请求发来时，尾插法；当有线程空闲时执行队列头的任务，头部删除法。

主线程思路：

socket bind listen
while(1)
{
   new_fd=accept()
   que_set()
   pthread_cond_signal(&cond);
}

线程思路：
while(1)
{
	
   拿任务   
   做任务
}

二、数据结构

队列结点

typedef struct tag_node{
	int new_fd;				//客户端套接字
	struct tag_node *pnext;
}node_t,*pnode_t;

队列

typedef struct{
	pnode_t que_head,que_tail;//头尾指针
	int que_capacity;		//容量，表示可连接的客户端上限
	int que_size;			//当前的结点数，表明有多少个客户端请求待应答
	pthread_mutex_t mutex;
}que_t,*pque_t;

线程池

typedef  void* (*pfunc)(void*);//定义了一种pfunc指向某种函数的指针类型。这种函数以一个void*为参数并返回void*类型。后面就可以像使用int,char一样使用pfunc了。
typedef struct{
    que_t que;				//队列类型，也是结构体
    pthread_cond_t cond;	//条件变量，为了让子线程睡觉
    pthread_t* pthid;		//子线程的指针，用指针是因为不知道要创建多少子进程
    int flag;				//线程启动标志
    pfunc thread_func;		//子线程入口函数
    int thread_num;			//线程数
}factory,*pfac;

数据传输用的“小火车”结构

typedef struct{
	int len;				//发送的文件长度	
	char buf[1000];			//文件内容
}train;

三、服务端代码实现

1.头文件

head.h，用于存放头文件

#ifndef __HEAD_H__
#define __HEAD_H__
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <strings.h>
#include <time.h>
#include <sys/msg.h>
#include <signal.h>
#include <sys/time.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <sys/uio.h>
#include <sys/epoll.h>
#include <errno.h>
#define FILENAME "filename.pdf"
typedef struct{
	int len;
	char buf[1000];
}train;
#endif

 
work_que.h，用于存放与队列相关的数据结构和函数声明

#ifndef _WORK_QUE_H
#define _WORK_QUE_H
#include "head.h"

//队列的单个结点，结点上的new_fd是客户端套接字
typedef struct tag_node{
    int new_fd;
    struct tag_node* pnext;
}node_t,*pnode_t;

//队列,用于存储待应答的客户端套接字
typedef struct{
    pnode_t que_head,que_tail;
    int que_capacity;//容量，表示可连接的客户端上限
    int que_size;//当前的结点数，表明有多少个客户端请求待应答
    pthread_mutex_t mutex;
}que_t,*pque_t;

void que_set(pque_t,pnode_t);
void que_get(pque_t,pnode_t*);
#endif

 
factory.h，用于存放线程池结构和相关函数声明

#ifndef __FACTORY_H__
#define __FACTORY_H__
#include "head.h"
#include "work_que.h"

typedef  void* (*pfunc)(void*);


typedef struct{
	que_t que;				//队列类型，也是结构体
	pthread_cond_t cond;	//条件变量，为了让子线程睡觉
	pthread_t* pthid;		//子线程的指针，用指针是因为不知道要创建多少子进程
	int flag;				//线程启动标志
	pfunc thread_func;		//子线程入口函数
	int thread_num;			//线程数
}factory,*pfac;

void factory_init(pfac p,int thread_num,int capacity,pfunc tran_file);
void factory_start(pfac);
int sendn(int,char*,int);
void trans_file(int);
#endif

2、源文件
factory.c

#include "factory.h"

void factory_init(pfac p,int thread_num,int capacity,pfunc th_func)
{
	p->que.que_head=NULL;
	p->que.que_tail=NULL;
	p->que.que_size=0;
	p->que.que_capacity=capacity;
	pthread_mutex_init(&p->que.mutex,NULL);
	pthread_cond_init(&p->cond,NULL);
	p->pthid=(pthread_t*)calloc(thread_num,sizeof(pthread_t));
	p->flag=0;//0代表未启动，1代表启动
	p->thread_func=th_func;
	p->thread_num=thread_num;
}

void factory_start(pfac p)
{
	if(0==p->flag)
	{
		int i;
		for(i=0;i<p->thread_num;i++)
		{
			pthread_create(p->pthid+i,NULL,p->thread_func,p);
		}
		p->flag=1;
	}else{
		printf("factory has start\n");
	}
}

 
work_que.c

#include "work_que.h"

void que_set(pque_t pq,pnode_t pnew)
{
	pthread_mutex_lock(&pq->mutex);
	if(NULL==pq->que_head)
	{
		pq->que_head=pnew;
		pq->que_tail=pnew;
	}else{
		//尾插法
		pq->que_tail->pnext=pnew;
		pq->que_tail=pnew;
	}
	pq->que_size++;
	pthread_mutex_unlock(&pq->mutex);
}

void que_get(pque_t pq,pnode_t *p)
{
	//从头开始删除节点，配合尾插法加入节点，形成了一个队列
	*p=pq->que_head;
	pq->que_head=pq->que_head->pnext;
	if(NULL==pq->que_head)
	{
		pq->que_tail=NULL;
	}
	pq->que_size--;
}

 
send_file.c

#include "factory.h"

void sig(int signum)
{
	printf("%d is coming\n",signum);
}

void trans_file(int new_fd)
{
	signal(SIGPIPE,sig);
	train t;
	strcpy(t.buf,FILENAME);//把文件名放入buf
	t.len=strlen(t.buf);
	sendn(new_fd,(char*)&t,4+t.len);//发送文件名火车给对端
	int fd;
	fd=open(FILENAME,O_RDONLY);
	if(-1==fd)
	{
		perror("open");
		return;
	}
	int ret;
	while(bzero(&t,sizeof(t)),(t.len=read(fd,t.buf,sizeof(t.buf)))>0)
	{//逗号表达式的结果就是最后一个表达式的结果
		ret=sendn(new_fd,(char*)&t,4+t.len);
		if(-1==ret)
		{
			goto end;
		}
	}
	//文件读完且发送完后，发送一个len成员为0且buf为空的数据，表示文件发送完毕
	t.len=0;
	sendn(new_fd,(char*)&t,4);
end:
	close(new_fd);
	close(fd);
}

 
tran_n.c

#include "head.h"

int sendn(int sfd,char* buf,int len)
{
	int total=0;
	int ret;
	while(total<len)
	{
			ret=send(sfd,buf+total,len-total,0);
			if(-1==ret)
			{
				printf("errno=%d\n",errno);
				return -1;
			}
			total=total+ret;
	}
	return 0;
}


void recvn(int sfd,char* buf,int len)
{
	int total=0;
	int ret;
	while(total<len)
	{
		ret=recv(sfd,buf+total,len-total,0);
		total=total+ret;
	}
}

 
main.c

#include "factory.h"

void* th_func(void* p)
{
	pfac pf=(pfac)p;
	pque_t pque=&pf->que;
	pnode_t pcur;
	while(1)
	{
		pthread_mutex_lock(&pque->mutex);
		if(0==pque->que_size)	//队列为空
		{
			//线程挂起，等待有客户端发来请求且加入了任务队列后发出的信号
			pthread_cond_wait(&pf->cond,&pque->mutex);
		}
		que_get(pque,&pcur);//线程从任务队列领取一个发送任务
		pthread_mutex_unlock(&pque->mutex);
		trans_file(pcur->new_fd);//线程开始执行传输任务
		free(pcur);
	}
}

int main(int argc,char* argv[])
{
	if(argc!=5)
	{
		printf("./thread_pool_server IP  PORT  thread_num capacity\n");
		return -1;
	}
	int thread_num=atoi(argv[3]);
	int capacity=atoi(argv[4]);

	//初始化并启动线程池
	factory f;
	factory_init(&f,thread_num,capacity,th_func);
	factory_start(&f);

	//socket bind listen
	int sfd;
	sfd=socket(AF_INET,SOCK_STREAM,0);
	if(-1==sfd)
	{
		perror("socket");
		return -1;
	}
	printf("sfd=%d\n",sfd);

	int resue=1;
	int ret;
	ret=setsockopt(sfd,SOL_SOCKET,SO_REUSEADDR,&resue,sizeof(int));
	if(-1==ret)
	{
		perror("setsockopt");
		return -1;
	}

	struct sockaddr_in ser;
	bzero(&ser,sizeof(ser));
	ser.sin_family=AF_INET;
	ser.sin_port=htons(atoi(argv[2]));//一定要用htons
	ser.sin_addr.s_addr=inet_addr(argv[1]);
	ret=bind(sfd,(struct sockaddr*)&ser,sizeof(struct sockaddr));
	if(-1==ret)
	{
		perror("bind");
		return -1;
	}

	listen(sfd,capacity);


	int new_fd;
	pque_t pque=&f.que;
	pnode_t pnew;
	while(1)
	{
		new_fd=accept(sfd,NULL,NULL);
		pnew=(pnode_t)calloc(1,sizeof(node_t));//申请内存耗时久，要放在锁外
		pnew->new_fd=new_fd;
		que_set(pque,pnew);//把客户端的下载请求加入任务队列
		printf("set in queue success\n");
		pthread_cond_signal(&f.cond);//唤醒子线程
	}
}

四、客户端代码实现
客户端代码可以与进程池客户端代码通用，故不再赘述。