Linux高性能服务器编程--线程池

用多进程或多线程实现并发服务器时有一些缺点：

（1）、动态创建子进程（或线程）比较耗费时间，会导致较慢的客户响应。

（2）、动态创建子进程（或线程）通常只用来为一个客户服务，这将导致系统上产生大量的细微进程（或线程）。进程（线程）间的切换将消耗大量的CPU时间。

所以有了池的概念。

池：在初始时，申请比刚开始要使用的资源大的资源空间，在接下来使用时，直接从池中获取资源。

对比多线程，多线程如果存在客户端链接，创建一个新的线程，客户端关闭，释放线程。服务器更多时间消耗在创建线程、释放线程。对于业务逻辑的处理，就会较少。所以用线程池来进行改善。

一、线程池服务器实现原理

在服务器运行初始时，创建n个和客户端通讯的工作线程，将这n个线程用池管理起来，主线程负责监听套接字、接受客户链接，当有连接时，从线程池中选取一个线程为其服务；客户端关闭连接时，服务器就将线程又放回池中。

二、线程池分配工作方式

服务器编程流程：

编程代码：

服务器端：

#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <pthread.h>
#include <semaphore.h>

#define MAX 10
int fds[MAX]={0};
sem_t sem;

void fds_init()
{
	int i=0;
	for(;i<MAX;i++)
	{
		fds[i]=-1;
	}
}

int fds_add(int c)
{
	int i=0;
	for(;i<MAX;i++)
	{
		if(fds[i]==-1)
		{
			fds[i]=c;
			return 1;
		}
	}
	return 0;
}

void fds_sub(int c)
{
	int i=0;
	for(;i<MAX-1;i++)
	{
		fds[i]=fds[i+1];
		if(fds[i+1]==-1)
			break;
	}
	fds[MAX-1]=-1;
}

int fds_get()
{
	int i=0;
	for(;i<MAX;i++)
	{
		if(fds[i]!=-1)
		{
			int c=fds[i];
			fds_sub(c);
			return c;
		}
	}
	return -1;
}

void *pthread_fun(void *arg)
{

	while(1)
	{
		sem_wait(&sem);
		int c=fds_get();
		while(1)
		{
			char buff[128]={0};
			int n=recv(c,buff,127,0);
			if(n<=0)
			{
				close(c);
				break;
			}
			printf("c=%d::buff=%s\n",c,buff);
			send(c,"I accept",sizeof("I accept"),0);
		}
	}
}

int main()
{	
	sem_init(&sem,0,0);
	fds_init();

	int i=0;
	for(;i<3;i++)
	{
		pthread_t id;
		int rt=pthread_create(&id,NULL,(void *)pthread_fun,NULL);
		assert(rt==0);
	}
	
	int sockfd=socket(AF_INET,SOCK_STREAM,0);
	assert(sockfd!=-1);

	struct sockaddr_in ser,cli;
	memset(&ser,0,sizeof(ser));
	ser.sin_family=AF_INET;
	ser.sin_addr.s_addr=inet_addr("127.0.0.1");
	ser.sin_port=htons(6500);
	
	int res=bind(sockfd,(struct sockaddr *)&ser,sizeof(ser));
	assert(res!=-1);
	
	listen(sockfd,5);

	while(1)
	{
		int len=sizeof(cli);
		int c=accept(sockfd,(struct sockaddr *)&cli,&len);
		if(c>=0)
		{
			if(!fds_add(c))
			{

				send(c,"please wait a memmet",strlen("please wait a memmet"),0);
				close(c);
				continue;
			}
			sem_post(&sem);
		}
		else
		{
			printf("error\n");
			continue;
		}
	}
}

客户端：

#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<signal.h>
#include<string.h>

int main()
{
	int sockfd=socket(PF_INET,SOCK_STREAM,0);
	assert(sockfd!=-1);

	struct sockaddr_in ser,cli;
	memset(&ser,0,sizeof(ser));
	ser.sin_family=AF_INET;
	ser.sin_port=htons(6500);
	ser.sin_addr.s_addr=inet_addr("127.0.0.1");

	int res=connect(sockfd,(struct sockaddr*)&ser,sizeof(ser));
	assert(res!=-1);

	while(1)
	{
		printf("please input:");
		fflush(stdout);
		char buff[128]={0};
		fgets(buff,128,stdin);
		if(strncmp(buff,"end",3)==0)
		{
			close(sockfd);
			break;
		}
		send(sockfd,buff,strlen(buff)-1,0);
		memset(buff,0,128);
		recv(sockfd,buff,127,0);
		printf("%s\n",buff);
	}
}

运行结果：

由于在线程池中创建了3个线程，所以由上面的图可以看出，当第四个客户端想要连接时会阻塞住。

接下来有客户端关闭时，通讯正常，如下图：

以上是通过方式1分配的流程，但仍然有风险，因为等待队列相当于临界资源，我们需要做加锁控制。所以有了第2中方案：