多进程并发编程-基于高级的预先创建进程池的模型

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

main{

socket();

bind();

listen();

for(i=0;i

pid=fork();

if(pid==0)//子进程

do_child();

}

waitpid();

close(fd);

}

do_child(){

while(1){

accept();

read();

write();

close();

}

}

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

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

服务器程序：

#include

#include

#include

#include

#include

#include

#include

#include

#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

{

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

#include

#include

#include

#include

#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的效率！