Linux TCP server系列(7)-select模式下的prefork server
2011-09-18 21:11 Aga.J 阅读(1665) 评论(0) 编辑 收藏 举报
目标:
多进程服务器的性能提升。
前面介绍过一种server模式为每个客户端连接都创建一个子进程,这种方式对server的压力较大,首先创建进程会消耗时间,其次,进程没有办法得到重复利用也会浪费了进程的创建,最后,进程间切换会带来性能上的影响。
本程序使用prefork思想,预先为server派生多个子进程,方便在需要时可以马上使用,而不需要等待进程创建,同时,进程还可以重复使用。
思路:
程序预先fork多个子进程,用来处理每个客户端socket的信息交互或者请求(决定预先fork多少个子进程是个问题!)一开始每个子进程都阻塞在和父进程的通信通道上,等待父进程的消息通知(处理某个客户请求),然后才执行与客户端socket的交互。
所有accept操作由“父进程”完成接收到客户端连接socket后,将该socket的文件描述符传送给子进程(怎么传送是一个问题!这里使用域socket来作为父子进程之间的通信介质—Unix域可以做到让同一台主机上的任何一个进程向其他进程传递打开的文件描述符,进程间用sendmsg在域套接口上发送一个特殊的消息,然后由内核做特殊处理,最后完成将打开的描述字从发送方传递到接收方,同时Unix域套接口也可以作为同一台主机上IPC通信的另一种方式,而且性能速度通常是TCP套接口的两倍【两个好处:速度快,可传递套接字】)。
同时,父进程还会使用select来监听所有孩子的通信介质,当子进程完成了客户端socket的信息交互请求后,就会通过该通信介质通知父进程,父进程在select捕获到消息后,则将发出该消息的子进程标识为空闲状态。
实现:
(1)父进程为了获知或者控制子进程,所以需要定义一个结构来维护子进程的信息
typedef struct
{
pid_t child_pid;
//进程ID
int child_pipefd; //父子间的stream pipe(连接父子进程的字节流管道描述字)
int child_status; //状态
long child_count;
//已处理的客户数
} Child;
(2)prefork
创建一定数量的子进程,同时每个子进程需要开启一条通道以便于和父进程做消息传递。
//initial "server 0.5" element
nchildren=10; //假设接收10个
navail=nchildren;
cptr=(Child*)calloc(nchildren,sizeof(Child));
for(i=0;i<nchildren;i++)
{
child_make(i,listenfd,addrlen);
//注意 这时候父进程还没有所谓的进程描述表项存在,没有所谓的文件打开描述结构
FD_SET(cptr[i].child_pipefd,&allset);
maxfd=std::max(maxfd,cptr[i].child_pipefd);
}
//initial "server
0.5" element
//child_make实现
pid_t child_make(int i, int listenfd, int addrlen)
{
int sockfd[2];
pid_t pid;
void
child_main(int,int,int);
socketpair(AF_LOCAL,SOCK_STREAM,0,sockfd);
if ( (pid=fork())>0)
{
close(sockfd[1]);
cptr[i].child_pid=pid;
cptr[i].child_pipefd=sockfd[0];
cptr[i].child_status=0;
return pid;
}
dup2(sockfd[1],STDERR_FILENO);
close(sockfd[0]);
close(sockfd[1]);
close(listenfd);
child_main(i,listenfd,addrlen);
}
注意到,子进程和父进程之间的通信通道是Unix域socket,这也是一种IPC的方式,而且它很适合进程在同一台机器上的情况,注意上述代码中对每个接口都很小心的做了处理(关闭等)。完成创建后,子进程执行child_main阻塞在Unix域socket的信息recv上。(父进程这时候只需要发送新接收的客户端socket fd即可以让子进程马上进行相应的处理)。
(3)父进程监听和消息通知
所有子进程创建后,父进程还需要监听和各个子进程的通信fd,因为每个子进程处理完父进程分配给他们的任务后,要告诉父进程,这样父进程就可以标识子进程为可用,从而做到复用子进程。
同时父进程当然也会监听listen
socket的fd,一旦有新连接来,它就会选取一个空闲子进程,然后通过unix域套接字将新连接socket fd作为消息发送给子进程。
这里的Unix域通信实现参考自网络
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 size_t recv_fd(int fd, void*data, size_t bytes, int*recvfd)
2 {
3 struct msghdr msghdr_recv; /*接收消息接收*/
4 struct iovec iov[1]; /*接收数据的向量*/
5 size_t n;
6 int newfd;
7 union{
8 struct cmsghdr cm;
9 char control[CMSG_SPACE(sizeof(int))];
10 }control_un;
11 struct cmsghdr*pcmsghdr; /*消息头部*/
12 msghdr_recv.msg_control = control_un.control; /*控制消息*/
13 msghdr_recv.msg_controllen = sizeof(control_un.control); /*控制消息的长度*/
14 msghdr_recv.msg_name = NULL; /*消息的名称为空*/
15 msghdr_recv.msg_namelen = 0; /*消息的长度为空*/
16
17 iov[0].iov_base = data; /*向量的数据为传入的数据*/
18 iov[0].iov_len = bytes; /*向量的长度为传入数据的长度*/
19 msghdr_recv.msg_iov = iov; /*消息向量指针*/
20 msghdr_recv.msg_iovlen = 1; /*消息向量的个数为1个*/
21 if((n = recvmsg(fd, &msghdr_recv, 0))<=0) /*接收消息*/
22 return n;
23 if((pcmsghdr = CMSG_FIRSTHDR(&msghdr_recv))!= NULL && /*获得消息的头部*/
24 pcmsghdr->cmsg_len == CMSG_LEN(sizeof(int))) { /*获得消息的长度为int*/
25 if(pcmsghdr->cmsg_level != SOL_SOCKET) /*消息的level应该为SOL_SOCKET*/ printf("control level != SOL_SOCKET\n");
26 if(pcmsghdr->cmsg_type != SCM_RIGHTS) /*消息的类型判断*/
27 printf("control type != SCM_RIGHTS\n");
28 *recvfd =*((int*)CMSG_DATA(pcmsghdr)); /*获得打开文件的描述符*/
29 } else
30 *recvfd = -1;
31 return n; /*返回接收消息的长度*/
32 }
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 ssize_t send_fd(int fd, void*data, size_t bytes, int sendfd)
2 {
3 struct msghdr msghdr_send; /*发送消息*/
4 struct iovec iov[1]; /*向量*/
5 size_t n; /*大小*/
6 int newfd; /*文件描述符*/ /*方便操作msg的结构*/
7 union{
8 struct cmsghdr cm; /*control msg结构*/
9 char control[CMSG_SPACE(sizeof(int))]; /*字符指针,方便控制*/
10 }control_un;
11 struct cmsghdr*pcmsghdr=NULL; /*控制头部的指针*/
12 msghdr_send.msg_control = control_un.control; /*控制消息*/
13 msghdr_send.msg_controllen = sizeof(control_un.control); /*长度*/
14 pcmsghdr = CMSG_FIRSTHDR(&msghdr_send); /*取得第一个消息头*/
15 pcmsghdr->cmsg_len = CMSG_LEN(sizeof(int)); /*获得长度*/
16 pcmsghdr->cmsg_level = SOL_SOCKET; /*用于控制消息*/
17 pcmsghdr->cmsg_type = SCM_RIGHTS;
18 *((int*)CMSG_DATA(pcmsghdr))= sendfd; /*socket值*/
19 msghdr_send.msg_name = NULL; /*名称*/
20 msghdr_send.msg_namelen = 0; /*名称长度*/
21 iov[0].iov_base = data; /*向量指针*/
22 iov[0].iov_len = bytes; /*数据长度*/
23 msghdr_send.msg_iov = iov; /*填充消息*/
24 msghdr_send.msg_iovlen = 1;
25 return (sendmsg(fd, &msghdr_send, 0)); /*发送消息*/
26 }
代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 | #include<sys/types.h> #include<sys/socket.h> #include<strings.h> #include<arpa/inet.h> #include<unistd.h> #include<stdlib.h> #include<stdio.h> #include<string.h> #include<errno.h> #include<signal.h> #include<sys/wait.h> #include<sys/time.h> #include<pthread.h> #include<algorithm> #include<sys/stat.h> #define LISTEN_PORT 84 /////////////////// size_t recv_fd( int fd, void *data, size_t bytes, int *recvfd) { struct msghdr msghdr_recv; /*接收消息接收*/ struct iovec iov[1]; /*接收数据的向量*/ size_t n; int newfd; union { struct cmsghdr cm; char control[CMSG_SPACE( sizeof ( int ))]; }control_un; struct cmsghdr*pcmsghdr; /*消息头部*/ msghdr_recv.msg_control = control_un.control; /*控制消息*/ msghdr_recv.msg_controllen = sizeof (control_un.control); /*控制消息的长度*/ msghdr_recv.msg_name = NULL; /*消息的名称为空*/ msghdr_recv.msg_namelen = 0; /*消息的长度为空*/ iov[0].iov_base = data; /*向量的数据为传入的数据*/ iov[0].iov_len = bytes; /*向量的长度为传入数据的长度*/ msghdr_recv.msg_iov = iov; /*消息向量指针*/ msghdr_recv.msg_iovlen = 1; /*消息向量的个数为1个*/ if ((n = recvmsg(fd, &msghdr_recv, 0))<=0) /*接收消息*/ return n; if ((pcmsghdr = CMSG_FIRSTHDR(&msghdr_recv))!= NULL && /*获得消息的头部*/ pcmsghdr->cmsg_len == CMSG_LEN( sizeof ( int ))) { /*获得消息的长度为int*/ if (pcmsghdr->cmsg_level != SOL_SOCKET) /*消息的level应该为SOL_SOCKET*/ printf ( "control level != SOL_SOCKET\n" ); if (pcmsghdr->cmsg_type != SCM_RIGHTS) /*消息的类型判断*/ printf ( "control type != SCM_RIGHTS\n" ); *recvfd =*(( int *)CMSG_DATA(pcmsghdr)); /*获得打开文件的描述符*/ } else *recvfd = -1; return n; /*返回接收消息的长度*/ } ssize_t send_fd( int fd, void *data, size_t bytes, int sendfd) { struct msghdr msghdr_send; /*发送消息*/ struct iovec iov[1]; /*向量*/ size_t n; /*大小*/ int newfd; /*文件描述符*/ /*方便操作msg的结构*/ union { struct cmsghdr cm; /*control msg结构*/ char control[CMSG_SPACE( sizeof ( int ))]; /*字符指针,方便控制*/ }control_un; struct cmsghdr*pcmsghdr=NULL; /*控制头部的指针*/ msghdr_send.msg_control = control_un.control; /*控制消息*/ msghdr_send.msg_controllen = sizeof (control_un.control); /*长度*/ pcmsghdr = CMSG_FIRSTHDR(&msghdr_send); /*取得第一个消息头*/ pcmsghdr->cmsg_len = CMSG_LEN( sizeof ( int )); /*获得长度*/ pcmsghdr->cmsg_level = SOL_SOCKET; /*用于控制消息*/ pcmsghdr->cmsg_type = SCM_RIGHTS; *(( int *)CMSG_DATA(pcmsghdr))= sendfd; /*socket值*/ msghdr_send.msg_name = NULL; /*名称*/ msghdr_send.msg_namelen = 0; /*名称长度*/ iov[0].iov_base = data; /*向量指针*/ iov[0].iov_len = bytes; /*数据长度*/ msghdr_send.msg_iov = iov; /*填充消息*/ msghdr_send.msg_iovlen = 1; return (sendmsg(fd, &msghdr_send, 0)); /*发送消息*/ } /////////////////// //服务器处理 void str_echo( int sockfd) // 服务器收到客户端的消息后的响应 { ssize_t n; char line[512]; printf ( "ready to read\n" ); while ( (n=read(sockfd,line,512))>0 ) //阻塞IO版本 { line[n]= '\0' ; printf ( "Client : %s\n" ,line); char msgBack[512]; snprintf(msgBack, sizeof (msgBack), "recv: %s\n" ,line); write(sockfd,msgBack, strlen (msgBack)); bzero(&line, sizeof (line)); } printf ( "end read\n" ); } //子进程结束的信号处理 float timeuse; void sig_child( int signo) //父进程对子进程结束的信号处理 { pid_t pid; int stat; struct timeval tpstart,tpend; //float timeuse; gettimeofday(&tpstart,NULL); while ( (pid=waitpid(-1,&stat,WNOHANG))>0) printf ( "child %d terminated\n" ,pid); gettimeofday(&tpend,NULL); timeuse+=1000000*(tpend.tv_sec-tpstart.tv_sec)+tpend.tv_usec-tpstart.tv_usec; //timeuse/=1000000; printf ( "Use Time:%f\n" ,timeuse/1000000); return ; } /* prefork + select */ typedef struct { pid_t child_pid; int child_pipefd; int child_status; long child_count; }Child; Child *cptr; //我们必须为每个进程维护一个信息结构来管理各子进程 //子进程ID,父子字节流管道描述字,子进程状态,子进程已处理客户数 pid_t child_make( int i, int listenfd, int addrlen) { int sockfd[2]; pid_t pid; void child_main( int , int , int ); socketpair(AF_LOCAL,SOCK_STREAM,0,sockfd); if ( (pid=fork())>0) { close(sockfd[1]); cptr[i].child_pid=pid; cptr[i].child_pipefd=sockfd[0]; cptr[i].child_status=0; return pid; } dup2(sockfd[1],STDERR_FILENO); close(sockfd[0]); close(sockfd[1]); close(listenfd); child_main(i,listenfd,addrlen); } //在使用fork创建子进程之前,先创建一个字节流管道(Unix域),随后利用管道通信 void child_main( int i, int listenfd , int addrlen) { char c; int connfd; ssize_t n; printf ( "child %ld starting\n" ,( long )getpid()); for (;;) { if ((n=recv_fd(STDERR_FILENO,&c,1,&connfd))==0) //FILE* newFile=new FILE(); //传递整个FILE结构也可以 //if((n=read(STDERR_FILENO,newFile,sizeof(FILE)))==0) //不能直接接收新连接的fd,因为这时候子进程fork出来时并没有所谓的进程fd表 //如果直接访问某个fd那会失败!!所以需要Unix域通信 { printf ( "read_fd returned 0\n" ); return ;} //else printf("connfd is %d\n",connfd); else printf ( "read success\n" ); //connfd=fileno(newFile); if (connfd<0) { printf ( "no descriptor form read_fd\n" ); return ;} else printf ( "fd is %d\n" ,connfd); str_echo(connfd); close(connfd); write(STDERR_FILENO, "\n" ,1); } //子进程初始化后,阻塞等待父进程接收到连接的socket后发过来 //发过来后,就开始在这个socket上等待,处理 //处理完成后,再写到管道,这时候父进程select的是各个子进程的管道 //一旦select到了,就表示子进程处理好了,就可以设置子进程为空闲 //下一个connect又可以给这个子进程来处理了。 //父子进程间,主要是通过read,write来写消息来完成控制! } //处理完客户请求后,通过字节流管道向父进程发回单个字节,通知父亲标识它为可用。 //如果意外终止,字节流管道所在端会关闭,read返回0,父进程捕获。 /* prefork + select */ static int nchildren; int main( int argc, char **argv) { int listenfd, connfd; pid_t childpid; socklen_t chilen; struct sockaddr_in chiaddr,servaddr; //for select int i,maxi,maxfd,sockfd; int nready,client[FD_SETSIZE]; ssize_t n; fd_set rset,allset; //for select listenfd=socket(AF_INET,SOCK_STREAM,0); if (listenfd==-1) { printf ( "socket established error: %s\n" ,( char *) strerror ( errno )); } bzero(&servaddr, sizeof (servaddr)); servaddr.sin_family=AF_INET; servaddr.sin_addr.s_addr=htonl(INADDR_ANY); servaddr.sin_port=htons(LISTEN_PORT); int bindc=bind(listenfd,( struct sockaddr *)&servaddr, sizeof (servaddr)); if (bindc==-1) { printf ( "bind error: %s\n" , strerror ( errno )); } listen(listenfd,SOMAXCONN); //limit是SOMAXCONN //for server 0.5 int navail,nset,rc; socklen_t addrlen; //cliaddr //for server 0.5 //initial "select" elements maxfd=listenfd; //新增listenfd,所以更新当前的最大fd maxi=-1; for (i=0;i<FD_SETSIZE;i++) client[i] = -1; FD_ZERO(&allset); FD_SET(listenfd,&allset); //end initial //initial "server 0.5" element nchildren=10; //假设接收10个 navail=nchildren; cptr=(Child*) calloc (nchildren, sizeof (Child)); for (i=0;i<nchildren;i++) { child_make(i,listenfd,addrlen); //注意 这时候父进程还没有所谓的进程描述表项存在,没有所谓的文件打开描述结构 FD_SET(cptr[i].child_pipefd,&allset); maxfd=std::max(maxfd,cptr[i].child_pipefd); } //initial "server 0.5" element int cliconn=0; signal (SIGCHLD,sig_child); for (;;) { //for select rset=allset; if ( navail<=0) FD_CLR( listenfd,&rset); //如果可用进程数为0,则将监听套接口从select描述字集中删除 //没有可用子进程前不accept它们。 nready=select(maxfd+1,&rset,NULL,NULL,NULL); //一开始select监听的是监听口 //如果有timeout设置,那么每次select之前都要再重新设置一下timeout的值 //因为select会修改timeout的值。 if (FD_ISSET(listenfd,&rset)) { chilen= sizeof (chiaddr); connfd=accept(listenfd,( struct sockaddr*)&chiaddr,&chilen); //阻塞在accept,直到三次握手成功了才返回 if (connfd==-1) printf ( "accept client error: %s\n" , strerror ( errno )); else printf ( "client connected:%d\n" ,++cliconn); // server 0.5 for (i=0;i<nchildren;i++) if (cptr[i].child_status==0) //找出第一个可用子进程 break ; if (i==nchildren) { printf ( "no available children" ); return 0; } cptr[i].child_status=1; cptr[i].child_count++; navail--; n=send_fd( cptr[i].child_pipefd,( void *) "" ,1,connfd); //n=write(cptr[i].child_pipefd,connFile,sizeof(FILE)); //printf("%d--%d\n",n,sizeof(FILE)); //n=write(cptr[i].child_pipefd,&connfd,sizeof(connfd)); //这时候不是说写个fd过去给孩子就可以,孩子根本就没有从父进程继承到这个记录 //因为是之前fork出来的子进程 printf ( "n is %d,connfd is %d , child id is %d\n" ,n, connfd,i); //把已连接描述字通过父子Unix域管道传递给子进程 //close(connfd); if (--nset==0) continue ; // server 0.5 //for select } // server 0.5 char rcc; for ( i=0;i<nchildren;i++) { if (FD_ISSET(cptr[i].child_pipefd,&rset)) { if ( ( n=read(cptr[i].child_pipefd,&rcc,1))==0) { printf ( "child %d terminated unexpectedly" ,i); return 0;} else printf ( "recycle client process: %d\n" ,i); //write过来的没有结束符,所以在write加个\n来表示行结束 cptr[i].child_status=0; navail++; if (--nset==0) break ; } } } } |
作者:Aga.J
出处:http://www.cnblogs.com/aga-j
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。
个人学习笔记仅供本人记录知识所用,不属发表性文章。
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· Java 中堆内存和栈内存上的数据分布和特点
· 开发中对象命名的一点思考
· .NET Core内存结构体系(Windows环境)底层原理浅谈
· C# 深度学习:对抗生成网络(GAN)训练头像生成模型
· .NET 适配 HarmonyOS 进展
· 如何给本地部署的DeepSeek投喂数据,让他更懂你
· 超详细,DeepSeek 接入PyCharm实现AI编程!(支持本地部署DeepSeek及官方Dee
· 用 DeepSeek 给对象做个网站,她一定感动坏了
· .NET 8.0 + Linux 香橙派,实现高效的 IoT 数据采集与控制解决方案
· DeepSeek处理自有业务的案例:让AI给你写一份小众编辑器(EverEdit)的语法着色文件