Chinaunix首页 | 论坛 | 博客

Renwenrenwen0524.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

Renwen0524

  • 博客访问： 578561
  • 博文数量： 65
  • 博客积分： 2844
  • 博客等级： 上尉
  • 技术积分： 996
  • 用 户 组： 普通用户
  • 注册时间： 2010-07-02 12:01
文章分类

全部博文（65）

文章存档

2014年（7）

2012年（20）

2011年（35）

2010年（3）

我的朋友
最近访客
推荐博文
相关博文
并发服务器模型：预先分配进程个数

分类： LINUX

2011-07-11 23:08:42

1、简介

在服务器端，主程序提前构建多个子进程，当客户端的请求到来时，系统从进程池中选取一个子进程来处理客户端的链接，每个子进程处理一个客户端的请求。在全部子进程的处理能力得到满足之前，服务器的网络负载是基本不变的。

此类服务器的一个难点是如何确定进程池中子进程的数量。因为子进程的数量在客户端连接之前已经构造好了，不能进行扩展。

2、tcp模型

 

image 

 

3、服务器端源代码（concurrency-server1.c）：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <errno.h>
  5. #include <sys/socket.h>
  6. #include <arpa/inet.h>
  7. #include <netinet/in.h>
  8. #include <sys/types.h>
  9. #include <unistd.h>
  10. #include <time.h>

  12. #define BUFLEN 1024
  13. #define PIDNUM 3

  15. /*******************并发服务器模型之一：预先分配好了进程的个数**********************/

  17. static void handle_fork(int sockfd){
  18.     int newfd;
  19.     struct sockaddr_in c_addr;
  20.     char buf[BUFLEN];
  21.     socklen_t len;
  22.     time_t now;
  23.     while(1){
  24.         len = sizeof(struct sockaddr);
  25.         if((newfd = accept(sockfd,(struct sockaddr*) &c_addr, &len)) == -1){
  26.             perror("accept");        
  27.             exit(errno);
  28.         }else
  29.         printf("\n*****************通信开始***************\n");
  30.         printf("正在与您通信的客户端是：%s: %d\n",inet_ntoa(c_addr.sin_addr),ntohs(c_addr.sin_port));

  32.         /******处理客户端请求*******/
  33.         bzero(buf,BUFLEN);
  34.         len = recv(newfd,buf,BUFLEN,0);
  35.         if(len >0 && !strncmp(buf,"TIME",4)){
  36.             bzero(buf,BUFLEN);
  37.             /*获取系统当前时间*/
  38.             now = time(NULL);
  39.             /*ctime将系统时间转换为字符串，sprintf使转化后的字符串保存在buf*/
  40.             sprintf(buf,"%24s\r\n",ctime(&now));
  41.             //******发送系统时间*******/
  42.             send(newfd,buf,strlen(buf),0);
  43.         }
  44.         /*关闭通讯的套接字*/
  45.         close(newfd);
  46.     }
  47. }

  49. int main(int argc, char **argv)
  50. {
  51.     int sockfd;
  52.     struct sockaddr_in s_addr;
  53.     unsigned int port, listnum;
  54.     pid_t pid[PIDNUM];
  55.     
  56.     /*建立socket*/
  57.     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
  58.         perror("socket");
  59.         exit(errno);
  60.     }else
  61.         printf("socket create success!\n");
  62.     /*设置服务器端口*/    
  63.     if(argv[2])
  64.         port = atoi(argv[2]);
  65.     else
  66.         port = 4567;
  67.     /*设置侦听队列长度*/
  68.     if(argv[3])
  69.         listnum = atoi(argv[3]);
  70.     else
  71.         listnum = 3;
  72.     /*设置服务器ip*/
  73.     bzero(&s_addr, sizeof(s_addr));
  74.     s_addr.sin_family = AF_INET;
  75.     s_addr.sin_port = htons(port);
  76.     if(argv[1])
  77.         s_addr.sin_addr.s_addr = inet_addr(argv[1]);
  78.     else
  79.         s_addr.sin_addr.s_addr = INADDR_ANY;
  80.     /*把地址和端口帮定到套接字上*/
  81.     if((bind(sockfd, (struct sockaddr*) &s_addr,sizeof(struct sockaddr))) == -1){
  82.         perror("bind");
  83.         exit(errno);
  84.     }else
  85.         printf("bind success!\n");
  86.     /*侦听本地端口*/
  87.     if(listen(sockfd,listnum) == -1){
  88.         perror("listen");
  89.         exit(errno);    
  90.     }else
  91.         printf("the server is listening!\n");
  92.     /*处理客户端的连接*/
  93.     int i = 0;
  94.     for(i = 0; i < PIDNUM; i++){
  95.         pid[i] = fork();
  96.         if(pid[i] == 0)
  97.             handle_fork(sockfd);    
  98.     }
  99.     /*关闭服务器的套接字*/
  100.     close(sockfd);
  101.     return 0;
  102. }

4、客户端源代码（concurrency-client.c）：

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <errno.h>
  5. #include <sys/socket.h>
  6. #include <arpa/inet.h>
  7. #include <netinet/in.h>
  8. #include <sys/types.h>
  9. #include <unistd.h>
  10. #include <time.h>

  12. #define BUFLEN 1024

  14. int main(int argc, char **argv)
  15. {
  16.     int sockfd;
  17.     struct sockaddr_in s_addr;
  18.     socklen_t len;
  19.     unsigned int port;
  20.     char buf[BUFLEN];    
  21.     
  22.     /*建立socket*/
  23.     if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1){
  24.         perror("socket");
  25.         exit(errno);
  26.     }else
  27.         printf("socket create success!\n");

  29.     /*设置服务器端口*/    
  30.     if(argv[2])
  31.         port = atoi(argv[2]);
  32.     else
  33.         port = 4567;
  34.     /*设置服务器ip*/
  35.     bzero(&s_addr, sizeof(s_addr));
  36.     s_addr.sin_family = AF_INET;
  37.     s_addr.sin_port = htons(port);
  38.     if (inet_aton(argv[1], (struct in_addr *)&s_addr.sin_addr.s_addr) == 0) {
  39.         perror(argv[1]);
  40.         exit(errno);
  41.     }
  42.     /*开始连接服务器*/    
  43.     if(connect(sockfd,(struct sockaddr*)&s_addr,sizeof(struct sockaddr)) == -1){
  44.         perror("connect");
  45.         exit(errno);
  46.     }else
  47.         printf("conncet success!\n");
  48.         
  49.     /******缓冲区清零*******/    
  50.     bzero(buf,BUFLEN);
  51.     strcpy(buf,"TIME");
  52.     /******发送消息*******/
  53.     send(sockfd,buf,strlen(buf),0);
  54.     /******缓冲区清零*******/
  55.     bzero(buf,BUFLEN);
  56.     /******接收消息*******/
  57.     len = recv(sockfd,buf,BUFLEN,0);
  58.     if(len > 0)
  59.         printf("服务器的系统时间是：%s\n",buf);
  60.         

  62.     /*关闭连接*/
  63.     close(sockfd);

  65.     return 0;
  66. }
5、编译源代码：
new@new-desktop:~/linux/c$ gcc -Wall concurrency-server1.c -o server
new@new-desktop:~/linux/c$ gcc -Wall concurrency-client.c -o client

6、运行就ok了，试试吧！

client_main

5、编译源代码：

gcc -Wall concurrency-server1.c -o server

gcc -Wall  concurrency-client.c -o client

6、运行就ok了，试试吧！
阅读(2539) | 评论(2) | 转发(2) |
0

上一篇：linux网络编程：并发服务器的模型

下一篇：并发服务器模型：预先分配线程个数，使用互斥锁

给主人留下些什么吧！~~

Renwen05242011-07-12 20:23:29

start4u: 貌似跟先分配几个子线程的模型差不多吧  你这个应该叫进程池了  跟线程池比有什么优势吗？.....
这只是一个并发服务器的模型，在没有线程时的使用，现在基本上不这么用。常用服务器的基本策略是利用事先分配好的子进程（也就是该模型）与可动态增加的子进程相结合的方法。如apache的web服务器就是这样实现的！

回复 | 举报

start4u2011-07-12 18:00:53

貌似跟先分配几个子线程的模型差不多吧  你这个应该叫进程池了  跟线程池比有什么优势吗？

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6