多进程并发编程----基于高级的预先创建进程池(accept不上锁)的模型

此篇博文先介绍最简单的服务器并发模型，此模型的大概框架如下：

main{
socket();
bind();
listen();
for(i=0;i<N;i++){
pid=fork();
if(pid==0)//子进程
do_child();
}
waitpid();
close(fd);
}
do_child(){
while(1){
accept();
read();
write();
close();
}
}

其实也很简单，程序开始就预先创建N个进程，创建的每一个子进程都循环调用accept函数阻塞在子进程，直到接收到新的客户端连接或者说是描述符s可读事件发生。而父进程只负责创建N个进程并等待进程的结束处理。

下面通过例子给大家介绍使用方法：

服务器程序：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
#define BUFFLEN 1024
#define SERVER_PORT 8888
#define BACKLOG 5
#define PIDNUMB 5
static void handle_connect(int s_s,int pid)
{
int s_c;	/*客户端套接字文件描述符*/
struct sockaddr_in from;	/*客户端地址*/
int len = sizeof(from);
printf("process %d is being to accept fd %d\n",pid,s_s);
/*主处理过程*/
while(1)
{
/*接收客户端连接*/
s_c = accept(s_s, (struct sockaddr*)&from, &len);
if(s_c > 0)
printf("process %d is being to handle client %d\n",pid,s_c);
time_t now;		/*时间*/
char buff[BUFFLEN];/*收发数据缓冲区*/
int n = 0;
memset(buff, 0, BUFFLEN);/*清零*/
n = recv(s_c, buff, BUFFLEN,0);/*接收发送方数据*/
if(n > 0 && !strncmp(buff, "TIME", 4))/*判断是否合法接收数据*/
{
memset(buff, 0, BUFFLEN);/*清零*/
now = time(NULL);/*当前时间*/
sprintf(buff, "%24s\r\n",ctime(&now));/*将时间拷贝入缓冲区*/
send(s_c, buff, strlen(buff),0);/*发送数据*/
}
/*关闭客户端*/
close(s_c);
}

}

void sig_int(int num)
{
exit(1);
}
int main(int argc, char *argv[])
{
int s_s;	/*服务器套接字文件描述符*/
struct sockaddr_in local;	/*本地地址*/
signal(SIGINT,sig_int);

/*建立TCP套接字*/
s_s = socket(AF_INET, SOCK_STREAM, 0);

/*初始化地址接哦股*/
memset(&local, 0, sizeof(local));/*清零*/
local.sin_family = AF_INET;/*AF_INET协议族*/
local.sin_addr.s_addr = htonl(INADDR_ANY);/*任意本地地址*/
local.sin_port = htons(SERVER_PORT);/*服务器端口*/

/*将套接字文件描述符绑定到本地地址和端口*/
int err = bind(s_s, (struct sockaddr*)&local, sizeof(local));
err = listen(s_s, BACKLOG);/*侦听*/

/*处理客户端连接*/
pid_t pid[PIDNUMB];
int i =0;
for(i=0;i<PIDNUMB;i++)
{
pid[i] = fork();
if(pid[i] == 0)/*子进程*/
{
printf("pid[%d]\n",getpid());
handle_connect(s_s,getpid());
}
}
while(1);

close(s_s);

return 0;
}

客户端程序：

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <stdio.h>

#define BUFFLEN 1024
#define SERVER_PORT 8888
int main(int argc, char *argv[])
{
int s;	/*服务器套接字文件描述符*/
struct sockaddr_in server;	/*本地地址*/
char buff[BUFFLEN];/*收发数据缓冲区*/
int n = 0;	/*接收字符串长度*/

/*建立TCP套接字*/
s = socket(AF_INET, SOCK_STREAM, 0);

/*初始化地址接哦股*/
memset(&server, 0, sizeof(server));/*清零*/
server.sin_family = AF_INET;/*AF_INET协议族*/
server.sin_addr.s_addr = htonl(INADDR_ANY);/*任意本地地址*/
server.sin_port = htons(SERVER_PORT);/*服务器端口*/

/*连接服务器*/
int err = connect(s, (struct sockaddr*)&server,sizeof(server));
memset(buff, 0, BUFFLEN);/*清零*/
strcpy(buff, "TIME");/*拷贝发送字符串*/
/*发送数据*/
send(s, buff, strlen(buff), 0);
memset(buff, 0, BUFFLEN);/*清零*/
/*接收数据*/
n = recv(s, buff, BUFFLEN, 0);
/*打印消息*/
if(n >0){
printf("TIME:%s\n",buff);
}
close(s);

return 0;
}

此模型面临一种“惊群”现象，也就是说连接到来之前所有子进程都处于睡眠状态，第一个链接到来会惊醒所有的子进程处于惊醒状态，但只有预先运行的子进程会处理这个连接，其他的子进程会检查内核维护的连接队列已经变成了0，那么这些子进程继续睡眠。

此模式最大的问题：

1  如何确定创建多少个进程，预先创建进程之后，无法再次修改进程数目

2  每个子进程都循环调用accept函数阻塞，浪费很多cpu和内存

针对上面提出的两个问题，有对应的解决方案（这两种方案都是实际工作中常用的方法，因为比较高级，处理起来比较复杂，所以放在后面的博文里面讲）：

1 针对1问题，可以搭配动态创建进程的方法，实现动态和静态创建进程，提高灵活性

2 针对2问题，创建N个进程之前，父进程负责accept函数的调用，收到新的连接后按照一定规则给分发给子进程。而子进程只负责处理数据，不再调用accept函数。这样大大提高了cpu的效率！