线程池实现高性能服务器

为了改善多进程和多线程实现服务器不停地创建删除进程或线程给系统带来的负担，引进了线程池，进程池来改善此种情况，此处以线程池为例。

1. 线程池原理：服务器启动则创建n个子进程或者函数线程，在服务器终止时销毁，如果有客户端连接，则分配一个子进程或者函数线程为其服务，服务完成之后则继续等待分配下一个客户端。
2. 线程池的优势：
   （1）、创建的进程或者线程是有限的，服务器的系统代价比较小，一般不会到达系统限制的值。
   （2）、服务器不需要频繁的创建、销毁进程或者线程，只在服务器启动时创建，结束时销毁。
   （3）、创建的进程或者线程不是为一个客户端服务，可以串行为多个客户端服务。
   （4）、客户端连接上以后，不需要再去创建进程或者线程，只需要分配进程池或者线程池中的进程或线程，减少了客户端等待的时间。
3. 线程池的逻辑（伪代码）：

int listenfd = socket();
int res = bind();
listen();
//创建线程池中所有的线程
while(1)
{
int c = accept();
//在线程池分配一个线程为C服务
}

4. 在代码实现时需要注意的问题：
   （1）、线程如何阻塞在线程池中 ；
   信号量P操作
   （2）、如何分配一个线程为客户端服务；
   主线程接受一个客户端连接执行V操作
   （3）、主线程如何传递客户端连接的文件描述符；
   全局维护一个数组或者链表
   （4）、再插入数据和获取数据时，每个线程都是互斥的，必须加锁。

5. 具体代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>
#include <semaphore.h>

#define THREADNUM  3
#define CLIENTNUM  10
sem_t sem;
pthread_mutex_t  mutex;

int ClientFds[CLIENTNUM];

void Init_ClientFds()
{
	int i = 0;
	for(; i < CLIENTNUM; ++i)
	{
		ClientFds[i] = -1;
	}
}

void Insert_Client(int fd)
{
	pthread_mutex_lock(&mutex);

	int i = 0;
	for(; i < CLIENTNUM; ++i)
	{
		if(ClientFds[i] == -1)
		{
			ClientFds[i] = fd;
			break;
		}
	}

	pthread_mutex_unlock(&mutex);
}

int Get_Client()
{
	pthread_mutex_lock(&mutex);

	int i = 0, c = -1;
	for(; i < CLIENTNUM; ++i)
	{
		if(ClientFds[i] != -1)
		{
			c = ClientFds[i];
			ClientFds[i] = -1;
			break;
		}
	}

	pthread_mutex_unlock(&mutex);

	return c;
}

void * DealClient(void * arg)
{
	while(1)
	{
		sem_wait(&sem);
		int  c = Get_Client();
		while(1)
		{
			char data[128] = {0};
			int n = recv(c, data, 127, 0);
			if(n <= 0)
			{
				close(c);
				break;
			}

			printf("%s\n", data);

			send(c, "OK", 2, 0);
		}
	}
}

int main()
{
	int listenfd = socket(AF_INET, SOCK_STREAM, 0);
	assert(listenfd != -1);

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

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

	listen(listenfd, 5);

	sem_init(&sem, 0, 0);
	pthread_mutex_init(&mutex, NULL);
	Init_ClientFds();

	//  创建线程池
	int i = 0;
	for(; i < THREADNUM; ++i)
	{
		pthread_t id;
		int res = pthread_create(&id, NULL, DealClient, NULL);
		assert(res  == 0);
	}

	while(1)
	{
		struct sockaddr_in cli;
		int len = sizeof(cli);

		int c = accept(listenfd, (struct sockaddr*)&cli, &len);
		assert(c != -1);

		Insert_Client(c);  //  将c传递给函数线程
		sem_post(&sem);   //  V操作
	}
}

6. 代码优化：
   我们为了保存文件描述符维护了一个数组，在代码中插入获取时都是从[0]遍历获取，加入56789，再取出56，此时又插入了10，那么下一次就会对10先进行操作，使后面的fd等待太久，因此对于代码中的GetClientFds()做了优化。

int  GetClientFds()  //只需将每次获取时整体向前挪一个单元格
{
      pthread_mutex_lock(&mutex);
      int i = 0;
      int c = ClientFds[0];
      for(; i < CLIENTNUM-1 || ClientFds[i] != -1 ; i++)
      {
            ClientFds[i] = ClientFds[i +1];
      }
      ClientFds[i] = -1;
      pthread_mutex_unlock(&mutex);
return c;
}

7. 维护文件描述符数组的方式：

第①种方式：

优点：只要数组中有fd就能立即处理
缺点：当fd插入不是很频繁的时候，会出现一直只调用第一个函数线程的情况，其他的函数线程一直未使用，造成资源的浪费。

第②种方式：

优点：只要分配合理，每一条线程都能得到利用
缺点：当其中的一个子线程fd处理比较麻烦时，后面分配给他的fd会滞留在数组中得不到及时的处理
相对比①②来说，②的处理方法更合理一些，这种方法可以做到负载均衡

8. 进程池和线程池的问题：
   进程池和线程池相比于多进程多线程有所改善，但当一个线程为一个客户端服务时，只能等客户端退出，才能服务下一个客户端，有可能出现客户端占着资源不使用，阻塞在recv函数的情况，对线程也是一种浪费，进程池同理，这种情况是之前提到服务器的通病，在select，poll，epoll，这三种方法建立的服务器会将这个问题解决。