TCP高性能服务器编程----多进程与多线程

首先回忆一下在tcp编程中，主要看一下服务器端的代码

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

#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>    //  IP地址转换函数
#include <netinet/in.h>   //  字节序转换函数

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

struct sockaddr_in  ser, cli;
memset(&ser, 0, sizeof(ser));
ser.sin_family = AF_INET;   //  地址族
ser.sin_port = htons(6000);
inet_aton("127.0.0.1", (struct in_addr*)&ser.sin_addr);

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

listen(listenfd,  2);

while(1)
{
	int  len = sizeof(cli);
	//   c特定客户端和服务器连接的文件描述符
	//   accept函数只有在有客户端连接的情况下返回
	int c = accept(listenfd, (struct sockaddr*)&cli, &len); // 阻塞运行
	assert(-1 != c);

	while(1)
	{
		char buff[128] = {0};
		int n = recv(c, buff,  2,  0); // 阻塞   有数据可读或者客户端退出都会返回
		if(n == 0)
		{
			printf("client  unlink\n");
			close(c);
			break;
		}
		else if(n == -1)
		{
			printf("error\n");
			close(c);
			break;
		}

		printf("n == %d:  %s\n", n, buff);

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

close(listenfd);

}

在这个中，我们可以看到以下问题：
（1）TCP服务器一次只能与一个客户端通讯
（2）如果服务器端的逻辑处理很复杂 ，则与一个客户端通讯也会存在效率问题。客户端一次请求可能需要的处理事件较长，则客户端必须等待服务器处理

因此，我们引进了多进程或者多线程处理：
在多进程中，父进程用来接收链接
子进程来处理与一个客户端的交互过程

在多线程中，主线程用来接收链接
函数线程与一个客户端进行交互过程
一、多进程
1、需要注意的问题：
（1）acccept()的返回值 c 不需要传递，因为fork之后，子进程可以直接通过 c访问此链接，
（2）父进程创建子进程后，必须调用 close©;因为父进程中的c会存在，子进程中也有一个，count会记录指向这个结构的个数，如果不在 父进程中调用close,系统并不会将该资源释放，造成资源浪费
子进程结束后，也调用close©;

下面是服务器端的代码：

#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 <signal.h>

void ChildDealClient(int c, struct sockaddr_in cli)
{
	while(1)
	{
		char data[128] = {0};
		int n = recv(c, data, 127, 0);
		if(n <= 0)
		{
			close(c);
			break;
		}

	printf("%s:%d :: %s\n", inet_ntoa(cli.sin_addr), ntohs(cli.sin_port),
		data);

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

printf("one client unlink\n");
}

int main()
{
	signal(SIGCHLD, SIG_IGN);
	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);

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

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

	pid_t pid = fork();
	assert(pid != -1);
	if(pid == 0)
	{
		ChildDealClient(c, cli);
		exit(0);
	}
	else
	{
		close(c);
	}
}

}

2、多进程存在的缺陷：
（1）创建一个进程，为一个客户端交互完成后，也会随之结束，有时候客户端链接上，什么也不做又会断开，因此会造成服务器系统负担
（2）如果客户端很多，则服务器创建的子进程也会很多，并且大部分子进程会阻塞在recv操作

二、多线程
1、需要注意的问题
（1）c需要通过线程创建函数以值传递的方式传递给函数线程
（2）close（c）只能是函数进程结束服务后调用，主线程不能调用

下面是代码：

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

void* CommClient(void *data)
{
	int c = (int)data;
	while(1)
	{
		char recvbuf[128] = {0};
		int n = recv(c,recvbuf,strlen(recvbuf)-1,0);
		if(n <= 0||strncmp(recvbuf,"end",3) == 0)
		{
			printf("one client break\n");
			close(c);
			break;
		}
		printf("%d:%s", c,recvbuf);
		send(c,"OK",2,0);
	}
	close(c);
}


int main(int argc, char const *argv[])
{
	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_port = htons(6000);
ser.sin_addr.s_addr = inet_addr("127.0.0.1");//New Change

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);//take a Link
	printf("This is PCB 's Addr:%x\n", &c);
	if(c < 0)
	{
		printf("link error");
		continue;
	}
	pthread_t id;
	int res = pthread_create(&id,NULL,CommClient,(void *)c);//void * c send accept-> c
	assert(res == 0);
	
}
close(sockfd);
}

2、存在的缺陷
（1）系统能够创建的进程或者一个进程能够创建的线程是有限的
（2）为一个客户端链接创建一个进程或者线程，客户端断开则销毁是不划算的