Linux网络编程：网络服务器的分类及运用

一、在之前设计的网络编程服务器中，涉及到的服务器都是最为简单的、一对一的服务器，也就是只与一个客户端建立通信。然而在网络程序里面,一般来说都是许多客户对应一个服务器，为了处理客户的请求, 对服务端的程序就提出了特殊的要求。

二、循环服务器和并发服务器

1、循环服务器：循环服务器描述了在一个时刻只处理一个请求的服务器实现方式，通过在单线程内设置循环控制实现对多个客户端请求的逐一响应，这种服务器的设计、编程、调试和修改往往比较容易去实现。在循环执行的服务器对预期的负载能提供足够的反应速度时常使用这种类型的服务器。循环服务器有有UDP循环服务器和TCP循环服务器两种类型。

①UDP循环服务器：

UDP循环服务器的实现方法:UDP服务器每次从套接字上读取一个客户端的请求，再对请求进行处理，然后将结果返回给客户机。其具体模型如下所示：

[html]  view plain  copy

 

1. <span style="font-family:KaiTi_GB2312;font-size:18px;">                socket(...);  
2.         bind(...);  
3.         while(1)  
4.            {  
5.                recvfrom(...);  
6.                process(...);  
7.                sendto(...);  
8.            }  
9. </span>  

对于此类服务器，由于UDP是非面向连接的,没有一个客户端可以老是占住服务端，因此UDP循环服务器对于每一个客户机的请求总是能够满足。

下面是UDP循环服务器的运用:

[html]  view plain  copy

 

1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <stdio.h>  
2. #include <stdlib.h>  
3. #include <string.h>  
4. #include <errno.h>  
5. #include <sys/types.h>  
6. #include <sys/socket.h>  
7. #include <arpa/inet.h>  
8.   
9. #define PORT 3212  
10. #define MAX_SIZE 512  
11.   
12. int main()  
13. {  
14.     int sockfd;  
15.     int len = sizeof(struct sockaddr);  
16.   
17.     char buf[MAX_SIZE];  
18.     char buffer[MAX_SIZE];  
19.   
20.     struct sockaddr_in serv_addr;  
21.       
22.     //创建套接字，IPV4／UDP  
23.     sockfd = socket(AF_INET,SOCK_DGRAM,0);  
24.     if(sockfd < 0)  
25.     {  
26.         printf("create socket error!\n");  
27.         exit(1);  
28.     }  
29.   
30.     //填充服务器信息  
31.     bzero(&serv_addr,sizeof(struct sockaddr_in));  
32.     serv_addr.sin_family = AF_INET;  
33.     serv_addr.sin_port = htons(PORT);  
34.     serv_addr.sin_addr.s_addr = inet_addr("192.168.1.132");  
35.   
36.     //绑定套接字  
37.     if(bind(sockfd,(struct sockaddr*)&serv_addr,sizeof(struct sockaddr)) < 0)  
38.     {  
39.         printf("bind error!\n");  
40.         exit(1);  
41.     }  
42.   
43.     //循环接收网络上发送来的数据并回复消息  
44.     while(1)  
45.     {  
46.         //接收数据  
47.         if(recvfrom(sockfd,buf,MAX_SIZE,0,(struct sockaddr*)&serv_addr,&len) < 0)  
48.         {  
49.             printf("recv error!\n");  
50.             exit(1);  
51.         }  
52.         printf("recv is: %s\n ",buf);  
53.               
54.       
55.         printf("write some text:");  
56.         scanf("%s",buffer);  
57.           
58.         //发送数据  
59.         if(sendto(sockfd,buffer,MAX_SIZE,0,(struct sockaddr*)&serv_addr,len) < 0)  
60.         {  
61.             printf("send error!\n");  
62.             fprintf(stderr,"send error:%s\n",strerror(errno));  
63.             exit(1);  
64.         }    
65.     }  
66.   
67.     //关闭连接  
68.     close(sockfd);  
69.   
70.   
71.     return 0;  
72. }  
73. </span>  

②TCP循环服务器：

TCP服务器接受一个客户端的连接,然后处理,完成了这个客户的所有请求后,断开连接。

[html]  view plain  copy

 

1. <span style="font-family:KaiTi_GB2312;font-size:18px;">        socket(...);  
2.     bind(...);  
3.     listen(...);  
4.     while(1)  
5.     {  
6.         accept(...);  
7.         process(...);  
8.         close(...);  
9.      }  
10.   
11. </span>  

因为TCP是面向连接的，故TCP循环服务器在同一时刻一次只能处理一个客户端的请求。只有在这个客户的所有请求都满足后, 服务器才可以继续后面的请求。这样如果有一个客户端占住服务器不放时,其它的客户机都不能工作了，因此,TCP服务器一般很少用循环服务器模型。

TCP循环服务器的运用：

[html]  view plain  copy

 

1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <stdlib.h>   
2. #include <stdio.h>   
3. #include <errno.h>   
4. #include <string.h>   
5. #include <netdb.h>   
6. #include <sys/types.h>   
7. #include <netinet/in.h>   
8. #include <sys/socket.h>   
9.   
10. #define portnumber 3000 //通信端口号  
11.   
12. int main(int argc, char *argv[])   
13. {   
14.     int sockfd,new_fd;   
15.     struct sockaddr_in server_addr;   
16.     struct sockaddr_in client_addr;   
17.     int sin_size;   
18.     int nbytes;  
19.     char buffer[1024];  
20.       
21.   
22.     /* 服务器端开始建立sockfd描述符 */   
23.     if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) // IPV4协议；TCP协议  
24.     {   
25.         fprintf(stderr,"Socket error:%s\n\a",strerror(errno));   
26.         exit(1);   
27.     }   
28.   
29.     /* 服务器端填充 sockaddr结构 */   
30.     bzero(&server_addr,sizeof(struct sockaddr_in)); // 初始化,置0  
31.     server_addr.sin_family=AF_INET;                 // IPV4  
32.     server_addr.sin_addr.s_addr=htonl(INADDR_ANY);  // (将本机器上的long数据转化为网络上的long数据)和任何主机通信，INADDR_ANY ：可以接收任意IP地址  
33.     //server_addr.sin_addr.s_addr=inet_addr("192.168.1.132");  //用于绑定到一个固定IP,inet_addr用于把数字加格式的ip转化为整形ip  
34.     server_addr.sin_port=htons(portnumber);         // (将本机器上的short数据转化为网络上的short数据)端口号  
35.       
36.     /* 捆绑sockfd描述符到IP地址 */   
37.     if(bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)   
38.     {   
39.         fprintf(stderr,"Bind error:%s\n\a",strerror(errno));   
40.         exit(1);   
41.     }   
42.   
43.     /* 设置允许连接的最大客户端数 */   
44.     if(listen(sockfd,5)==-1)   
45.     {   
46.         fprintf(stderr,"Listen error:%s\n\a",strerror(errno));   
47.         exit(1);   
48.     }   
49.   
50.     while(1)   
51.     {   
52.         /* 服务器阻塞,直到客户程序建立连接 */   
53.         sin_size=sizeof(struct sockaddr_in);   
54.         if((new_fd=accept(sockfd,(struct sockaddr *)(&client_addr),&sin_size))==-1)   
55.         {   
56.             fprintf(stderr,"Accept error:%s\n\a",strerror(errno));   
57.             exit(1);   
58.         }   
59.         fprintf(stderr,"Server get connection from %s\n",inet_ntoa(client_addr.sin_addr)); // 将网络地址转换成.字符串  
60.           
61.         if((nbytes=read(new_fd,buffer,1024))==-1)   
62.         {   
63.             fprintf(stderr,"Read Error:%s\n",strerror(errno));   
64.             exit(1);   
65.         }         
66.         buffer[nbytes]='\0';  
67.         printf("Server received %s\n",buffer);  
68.           
69.         /* 这个通讯已经结束 */   
70.         close(new_fd);   
71.         /* 循环下一个 */   
72.     }   
73.   
74.     /* 结束通讯 */   
75.     close(sockfd);   
76.     exit(0);   
77. } </span>  

这种服务器有下面这些缺点：

*若服务器正在处理一个客户端请求时另一个请求到来，系统会将该新的请求排队，第二个请求须等待第一个请求处理完才能开始，这就造成在客户请求过于频繁也就是客户请求过多时服务器的请求队伍会越来越长，响应时间也就越来越久。

*如果一个服务器的设计的处理能力为处理K个客户端，而每个客户端每秒发送N个请求，则此服务器的请求处理时间必须小于每个请求1\(K*N)s。若服务器无法达到该要求则会造成客户的请求队列溢出。这也就衍生出了并发服务器。

2、并发服务器：

并发服务器在同一个时刻可以响应多个客户端的请求，将并发引入的原因是需要给多个客户提供快速的响应时间。并发方式处理多个客户的请求是目前最为广泛运用的服务器类型，常见的并发服务器的实现是多线程机制（也可以使用多进程，不过这种方法消耗资源太大，通常不使用），在多线程机制中服务器主线程为每个到来的客户请求创建一个子线程进行服务，这类服务器的编写规则通常如下：

第一部分的代码负责监听并接收客户请求，为客户请求创建新的服务器线程；第二部分的代码负责处理单个客户的请求。关于多线程机制并发服务器的设计流程如下：

[html]  view plain  copy

 

1. <span style="font-family:KaiTi_GB2312;font-size:18px;">   socket(...);  
2.    bind(...);  
3.    listen(...);  
4.    while(1)   
5.   {  
6.      accept(...);  
7.          if(fork(..)==0) //创建线程处理请求  
8.          {  
9.           process(...);  
10.           close(...);  
11.               exit(...); //处理结束，退出线程  
12.       }  
13.       close(...);   
14.    }  
15. </span>  

TCP并发服务器（多线程机制）的运用：

[html]  view plain  copy

 

1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <stdlib.h>  
2. #include <stdio.h>  
3. #include <errno.h>  
4. #include <string.h>  
5. #include <netdb.h>  
6. #include <sys/types.h>  
7. #include <netinet/in.h>  
8. #include <sys/socket.h>  
9.   
10. #define portnumber 3000  
11.   
12. void * read_msg(void *arg) //处理客户请求(读取客户端数据）  
13. {  
14.     int fd = *((int *)arg);  
15.     int nread = 0;  
16.     char buffer[1024];  
17.   
18.     while((nread = read(fd,buffer,sizeof(buffer))) > 0)  
19.     {  
20.         buffer[nread] = '\0';  
21.         printf("get client message: %s\n",buffer);  
22.         memset(buffer,0,sizeof(buffer));  
23.     }  
24. }  
25.   
26.   
27. int main(int argc, char *argv[])  
28. {  
29.     int sockfd,new_fd;  
30.     struct sockaddr_in server_addr;  
31.     struct sockaddr_in client_addr;  
32.     int sin_size;  
33.     int nbytes;  
34.     char buffer[1024];  
35.   
36.     pthread_t id;  
37.   
38.   
39.     /* 服务器端开始建立sockfd描述符 */  
40.     if((sockfd=socket(AF_INET,SOCK_STREAM,0))==-1) // AF_INET:IPV4;SOCK_STREAM:TCP  
41.     {  
42.         fprintf(stderr,"Socket error:%s\n\a",strerror(errno));  
43.         exit(1);  
44.     }  
45.   
46.     /* 服务器端填充 sockaddr结构 */  
47.     bzero(&server_addr,sizeof(struct sockaddr_in)); // 初始化,置0  
48.     server_addr.sin_family=AF_INET;                 // Internet  
49.     server_addr.sin_addr.s_addr=htonl(INADDR_ANY);  // 和任何主机通信，INADDR_ANY可以接收任意IP地址  
50.     //server_addr.sin_addr.s_addr=inet_addr("192.168.1.132");  //用于绑定到一个固定IP,inet_addr用于把数字加格式的ip转化为整形ip  
51.     server_addr.sin_port=htons(portnumber);         // (将本机器上的short数据转化为网络上的short数据)端口号  
52.   
53.     /* 捆绑sockfd描述符到IP地址 */  
54.     if(bind(sockfd,(struct sockaddr *)(&server_addr),sizeof(struct sockaddr))==-1)  
55.     {  
56.         fprintf(stderr,"Bind error:%s\n\a",strerror(errno));  
57.         exit(1);  
58.     }  
59.   
60.     /* 设置允许连接的最大客户端数 */  
61.     if(listen(sockfd,5)==-1)  
62.     {  
63.         fprintf(stderr,"Listen error:%s\n\a",strerror(errno));  
64.         exit(1);  
65.     }  
66.   
67.     while(1)  
68.     {  
69.         /* 服务器阻塞,直到客户程序建立连接 */  
70.         sin_size=sizeof(struct sockaddr_in);  
71.         printf("accepting!\n");  
72.         if((new_fd=accept(sockfd,(struct sockaddr *)(&client_addr),&sin_size))==-1)  
73.         {  
74.             fprintf(stderr,"Accept error:%s\n\a",strerror(errno));  
75.             exit(1);  
76.         }  
77.         fprintf(stderr,"Server get connection from %s\n",inet_ntoa(client_addr.sin_addr)); // 将网络地址转换成.字符串  
78.           
79.         pthread_create(&id,NULL,(void *)read_msg,(void *)&new_fd); //创建线程  
80.   
81.     }  
82.   
83.     /* 结束通讯 */  
84.     close(sockfd);  
85.     exit(0);  
86. }</span>  

对于并发服务器也可以用子进程方式实现：

[html]  view plain  copy

 

1. <span style="font-family:KaiTi_GB2312;font-size:18px;">#include <stdlib.h>   
2. #include <stdio.h>   
3. #include <errno.h>   
4. #include <string.h>   
5. #include <netdb.h>   
6. #include <sys/types.h>   
7. #include <netinet/in.h>   
8. #include <sys/socket.h>   
9.   
10. #define MY_PORT 3000  
11.   
12. int main(int argc ,char **argv)  
13. {  
14.     int listen_fd,accept_fd;  
15.     struct sockaddr_in  client_addr;  
16.     int n;  
17.     int nbytes;  
18.    
19.     if((listen_fd=socket(AF_INET,SOCK_STREAM,0))<0)  
20.     {  
21.             printf("Socket Error:%s\n\a",strerror(errno));  
22.             exit(1);  
23.     }  
24.    
25.     bzero(&client_addr,sizeof(struct sockaddr_in));  
26.     client_addr.sin_family=AF_INET;  
27.     client_addr.sin_port=htons(MY_PORT);  
28.     client_addr.sin_addr.s_addr=htonl(INADDR_ANY);  
29.     n=1;  
30.    
31.     /* 如果服务器终止后,服务器可以第二次快速启动而不用等待一段时间  */  
32.     setsockopt(listen_fd,SOL_SOCKET,SO_REUSEADDR,&n,sizeof(int));  
33.     if(bind(listen_fd,(struct sockaddr *)&client_addr,sizeof(client_addr))<0)  
34.     {  
35.             printf("Bind Error:%s\n\a",strerror(errno));  
36.             exit(1);  
37.     }  
38.     
39.     listen(listen_fd,5);  
40.       
41.     while(1)  
42.     {  
43.         accept_fd=accept(listen_fd,NULL,NULL);  
44.         if((accept_fd<0)&&(errno==EINTR))  
45.                 continue;  
46.         else if(accept_fd<0)  
47.             {  
48.                 printf("Accept Error:%s\n\a",strerror(errno));  
49.                 continue;  
50.             }  
51.         if((n=fork())==0)  
52.         {  
53.                 /* 子进程处理客户端的连接 */  
54.                 char buffer[1024];  
55.   
56.                 if((nbytes=read(accept_fd,buffer,1024))==-1)   
57.             {   
58.                 fprintf(stderr,"Read Error:%s\n",strerror(errno));   
59.                 exit(1);   
60.             }         
61.             buffer[nbytes]='\0';  
62.             printf("Server received %s\n",buffer);  
63.                   
64.                 close(listen_fd);  
65.                 close(accept_fd);  
66.                 exit(0);  
67.         }  
68.         else   
69.             close(accept_fd);  
70.     }  
71. } </span>