Linux 系统应用编程——网络编程（服务器模型）

在网络通信过程中，服务端通常需要处理多个客户端。由于多个客户端的请求可能会同时到来，服务器端可采用不同的方法来处理。总体上来说，服务器端可采用两种模型来实现：循环服务器模型和并发服务器模型。

循环服务器模型是指服务器端依次处理每个客户端，直到当前客户端的所有请求处理完毕，再处理下一个客户端。这类模型的优点是简单，缺点显而易见。特别是TCP循环服务器模型，由于必须先处理完当前客户端，容易造成其他客户端等待时间较长的情况。

为了提高服务器的并发处理能力，又引入了并发服务器模型。其基本思想是在服务器端此阿勇多任务机制（多进程或多线程），分别为每个客户端创建一个任务来处理，极大地提高了服务器的并发处理能力。

下面具体介绍循环服务器模型和并发服务器模型的流程及实现。为了更好的进行对比。本节均以TCP为例讨论相关模型。

一、循环服务器（TCP）

1、运行介绍

TCP循环服务器是一种常用的模型，其工作流程如下：

1）服务器端从连接请求队列中提取请求，建立连接并返回新的已连接套接字；

2）服务器端通过已连接套接字循环接收数据，处理并发送给客户端，知道客户端关闭连接；

3）服务器端关闭已连接套接字，返回步骤1；

2、特点分析

通过上面对服务器执行过程的介绍，可以得到以下结论。

1）服务器端采用循环嵌套来实现。外层循环依次提取每个客户端的连接请求，建立TCP连接。内层循环接受并处理当前客户端的所有数据，知道客户端关闭连接；

2）如果当前客户端没有处理结束，其他客户端必须一直等待。

注意：采用这种模型的服务器无法同时为多个客户端服务。

3、编程示例

下面实现 TCP ECHO 服务器端和客户端。服务器端接收到客户端数据后，原封不动发送回去（回射服务）；客户端运行时，用户从键盘输入字符串，发送给服务器端并接受返回的数据，直到用户输入quit 后退出。

server.c

[cpp] view plaincopy  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <string.h>  
 #include <sys/types.h>  
 #include <sys/socket.h>  
 #include <unistd.h>  
 #include <netinet/in.h>  
 #include <arpa/inet.h>  
 #define BUFFER_SIZE 128  
 #define PORT 8888  
   
 int main()  
 {  
     int listenfd, clientfd;  
     int n;  
     struct sockaddr_in serveraddr,clientaddr;  
     socklen_t peerlen;  
     char buffer[BUFFER_SIZE];  
   
     if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
     {  
         perror("socket error");  
         exit(-1);  
     }  
     else  
     {  
         printf("listenfd:%d\n",listenfd);  
     }  
   
     memset(&serveraddr,0,sizeof(serveraddr));  
     serveraddr.sin_family = AF_INET;  
     serveraddr.sin_port = htons(PORT);  
     serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);  
   
     if(bind(listenfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr)) < 0) //绑定IP地址和端口号  
     {  
         perror("bind error");  
         exit(-1);  
     }  
     else  
     {  
         printf("bind successfully!\n");  
     }  
   
     if(listen(listenfd,10) == -1)  
     {  
         perror("listen error");  
         exit(-1);  
     }  
     else  
     {  
         printf("listening....\n");  
     }  
   
     peerlen = sizeof(clientaddr);  
     while(1)  
     {  
         if((clientfd = accept(listenfd,(struct sockaddr *)&clientaddr,&peerlen)) < 0) //循环等待客户端的连接  
         {  
             perror("accept error");  
             exit(-1);  
         }  
         else  
         {  
             printf("connection from [%s:%d]\n",inet_ntoa(clientaddr.sin_addr)  
                     ,ntohs(clientaddr.sin_port));     
         }  
   
         memset(buffer,0,sizeof(buffer));  
         while(1)  
         {  
             if((n = recv(clientfd,buffer,BUFFER_SIZE,0)) == -1) //循环接收客户端发送的数据  
             {  
                 perror("recv error");  
                 exit(-1);  
             }  
             else if(n == 0) //此时，客户端断开连接  
             {  
                 break;  
             }  
             else  
             {  
                 printf("Received message:%s\n",buffer);  
                 if(send(clientfd, buffer, n, 0) == -1)  
                 {  
                     perror("send error");  
                     exit(-1);  
                 }  
                 else  
                 {  
                     printf("sendmessage:%s\n",buffer);  
                 }  
             }  
         }  
         close(clientfd); //客户端断开连接后，服务端也断开  
     }  
     close(listenfd);  
   
     return 0;  
 }  

client.c

[cpp] view plaincopy  
 #include <stdio.h>  
 #include <string.h>  
 #include <stdlib.h>  
 #include <unistd.h>  
 #include <sys/socket.h>  
 #include <sys/types.h>  
 #include <netinet/in.h>  
 #include <arpa/inet.h>  
 #define BUFFER_SIZE 128  
 #define PORT 8888  
   
 int main()  
 {  
     int n;  
     int serverfd, clientfd;  
     struct sockaddr_in serveraddr;  
     char buffer[BUFFER_SIZE];  
   
     if((clientfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
     {  
         perror("socket error");  
         exit(-1);  
     }  
     else  
     {  
         printf("clientfd:%d\n",clientfd);  
     }  
 //设置服务端的IP地址和端口号  
     memset(&serveraddr,0,sizeof(serveraddr));  
     serveraddr.sin_family = AF_INET;  
     serveraddr.sin_port = htons(PORT);  
     serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);  
   
     if(connect(clientfd,(struct sockaddr *)&serveraddr, sizeof(serveraddr)) == -1)  
     {  
         perror("connect error");  
         exit(-1);  
     }  
     else  
     {  
         printf("connect successfully!\n");  
     }  
   
     while(1)  
     {         
         printf("input > ");  
         fgets(buffer,sizeof(buffer),stdin);  
         if(strcmp(buffer,"quit\n") == 0) //遇到quit，退出  
             break;  
         buffer[strlen(buffer) - 1] = '\0'; //将'\n'去掉  
         if(send(clientfd,buffer,sizeof(buffer),0) == -1)  
         {  
             perror("send error");  
             exit(-1);  
         }  
         memset(buffer,0,sizeof(buffer)); //清空buffer  
         if((n = recv(clientfd,buffer,sizeof(buffer),0)) == -1)  
         {  
             perror("recv error");  
             exit(-1);  
         }  
         else if(n == 0)  
         {  
             break; //若服务端意外关闭  
         }  
         else  
         {  
             printf("echo:%s\n",buffer);  
         }  
     }  
     close(clientfd);  
   
     return 0;  
 }  

运行结果如下：

server

[cpp] view plaincopy  
 fs@ubuntu:~/qiang/netprogram/2$ ./server   
 listenfd:3  
 bind successfully!  
 listening....  
 connection from [127.0.0.1:57366]  
 Received message:xiao  
 sendmessage:xiao  
 Received message:zhi  
 sendmessage:zhi  
 Received message:qiang  
 sendmessage:qiang  
   
 //继续等待下一个客户端的连接  

client

[cpp] view plaincopy  
 fs@ubuntu:~/qiang/netprogram/2$ ./client   
 clientfd:3  
 connect successfully!  
 input > xiao  
 echo:xiao  
 input > zhi  
 echo:zhi  
 input > qiang  
 echo:qiang  
 input > quit  
 fs@ubuntu:~/qiang/netprogram/2$   

二、并发服务器（TCP）

1、运行介绍

TCP并发服务器模型在网络通信中被广泛使用，既可以采用多进程也可以采用多线程来实现。以多进程为例，其工作流程如下：

1）服务器端父进程从连接请求队列中提取请求，建立连接并返回新的已连接套接字。

2）服务器端父进程创建子进程为客户端服务。客户端关闭连接时，子进程结束。

3）服务器端父进程关闭已连接套接字，返回步骤1；

2、特点分析

通过上面对服务器执行过程的介绍，可以得到以下结论。

1）服务器端父进程一旦接受到客户端的连接请求，建立好连接并创建新的子进程。这意味着每个客户端在服务器端有一个专门的子进程为其服务。

2）服务器端的多个子进程同时运行（宏观上），处理多个客户端。

3）服务器端的父进程不具体处理每个客户端的数据请求。

注意：采用这种模型的服务器端需要避免僵死进程。

3、编程示例

下面采用并发模型实现 TCP ECHO服务器端。

server.c

[cpp] view plaincopy  
 #include <stdio.h>  
 #include <stdlib.h>  
 #include <string.h>  
 #include <sys/types.h>  
 #include <sys/socket.h>  
 #include <unistd.h>  
 #include <netinet/in.h>  
 #include <arpa/inet.h>  
 #include <signal.h>  
 #define BUFFER_SIZE 128  
 #define PORT 8888  
 #define IP "192.168.3.51"  
   
 void handler(int signo);  
   
 int main()  
 {  
     int listenfd, clientfd;  
     int n;  
     pid_t pid;  
     struct sockaddr_in serveraddr,clientaddr;  
     socklen_t peerlen;  
     char buffer[BUFFER_SIZE];  
   
     if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
     {  
         perror("socket error");  
         exit(-1);  
     }  
     else  
     {  
         printf("Socket successfully!\nlistenfd:%d\n",listenfd);  
     }  
   
     memset(&serveraddr,0,sizeof(serveraddr));  
     serveraddr.sin_family = AF_INET;  
     serveraddr.sin_port = htons(PORT);  
     serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);  
   
     if(bind(listenfd,(struct sockaddr *)&serveraddr,sizeof(serveraddr)) < 0)  
     {  
         perror("bind error");  
         exit(-1);  
     }  
     else  
     {  
         printf("bind successfully!\n");  
         printf("local IP:%s port:%d\n",IP,PORT);  
     }  
   
     if(listen(listenfd,10) == -1)  
     {  
         perror("listen error");  
         exit(-1);  
     }  
     else  
     {  
         printf("listening....\n");  
     }  
   
     signal(SIGCHLD,handler);//捕捉SIGCHLD信号，子进程死亡后，调用handler回收      
     peerlen = sizeof(clientaddr);  
     while(1)  
     {  
         if((clientfd = accept(listenfd,(struct sockaddr *)&clientaddr,&peerlen)) < 0)  
         {  
             perror("accept error");  
             exit(-1);  
         }  
         else  
         {  
             printf("connection from [%s:%d]\n",inet_ntoa(clientaddr.sin_addr)  
                     ,ntohs(clientaddr.sin_port));     
         }  
   
         memset(buffer,0,sizeof(buffer));  
         if((pid = fork()) < 0)  
         {  
             perror("fork error");  
             exit(-1);  
         }  
         else if(pid == 0)  
         {  
             close(listenfd);  
             while(1)  
             {  
                 if((n = recv(clientfd,buffer,BUFFER_SIZE,0)) == -1)  
                 {  
                     perror("recv error");  
                     exit(-1);  
                 }  
                 else if(n == 0)  
                 {  
                     break;  
                 }  
                 else  
                 {  
                     printf("Received message:%s\n",buffer);  
                 }  
               
                 if(send(clientfd, buffer, n, 0) == -1)  
                 {  
                     perror("send error");  
                     exit(-1);  
                 }  
                 else  
                 {  
                     printf("sendmessage:%s\n",buffer);  
                 }  
             }  
             printf("client is closed\n");  
             exit(0);  
         }  
         else  
         {  
             close(clientfd);  
         }  
     }  
     close(listenfd);  
   
     return 0;  
 }  
 //接收到SIFCHLD信号后，回收子进程  
 void handler(int signo)  
 {  
     pid_t pid;  
     while((pid = waitpid(-1, NULL, WNOHANG)) > 0)  
     {  
         printf("child(%d) is over!\n",pid);  
     }  
 }  

client

[cpp] view plaincopy  
 #include <stdio.h>  
 #include <string.h>  
 #include <stdlib.h>  
 #include <unistd.h>  
 #include <sys/socket.h>  
 #include <sys/types.h>  
 #include <netinet/in.h>  
 #include <arpa/inet.h>  
 #define BUFFER_SIZE 128  
 #define PORT 8888  
   
 int main()  
 {  
     int n;  
     int serverfd, clientfd;  
     struct sockaddr_in serveraddr;  
     char buffer[BUFFER_SIZE];  
   
     if((clientfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
     {  
         perror("socket error");  
         exit(-1);  
     }  
     else  
     {  
         printf("clientfd:%d\n",clientfd);  
     }  
   
     memset(&serveraddr,0,sizeof(serveraddr));  
     serveraddr.sin_family = AF_INET;  
     serveraddr.sin_port = htons(PORT);  
     serveraddr.sin_addr.s_addr = htonl(INADDR_ANY);  
   
     if(connect(clientfd,(struct sockaddr *)&serveraddr, sizeof(serveraddr)) == -1)  
     {  
         perror("connect error");  
         exit(-1);  
     }  
     else  
     {  
         printf("connect successfully!\n");  
     }  
   
     while(1)  
     {         
         printf("input > ");  
         fgets(buffer,sizeof(buffer),stdin);  
         if(strcmp(buffer,"quit\n") == 0)  
             break;  
         buffer[strlen(buffer) - 1] = '\0';  
         if(send(clientfd,buffer,sizeof(buffer),0) == -1)  
         {  
             perror("send error");  
             exit(-1);  
         }  
         memset(buffer,0,sizeof(buffer));  
         if((n = recv(clientfd,buffer,sizeof(buffer),0)) == -1)  
         {  
             perror("recv error");  
             exit(-1);  
         }  
         else if(n == 0)  
         {  
             break;  
         }  
         else  
         {  
             printf("echo:%s\n",buffer);  
         }  
     }  
     close(clientfd);  
   
     return 0;  
 }  

执行结果如下：

client1:

[cpp] view plaincopy  
 fs@ubuntu:~/qiang/netprogram/3$ ./client   
 clientfd:3  
 connect successfully!  
 input > I am client1!  
 echo:I am client1!  
 input > I am client1, how are you!  
 echo:I am client1, how are you!  
 input > quit  
 fs@ubuntu:~/qiang/netprogram/3$   

clinet2:

[cpp] view plaincopy  
 fs@ubuntu:~$ telnet 192.168.3.51 8888  
 Trying 192.168.3.51...  
 Connected to 192.168.3.51.  
 Escape character is '^]'.  
 I am client2! I am telnet  
 I am client2! I am telnet  
 I am telnet, I am still alive!   
 I am telnet, I am still alive!  

server:

[cpp] view plaincopy  
 fs@ubuntu:~/qiang/netprogram/3$ ./server   
 Socket successfully!  
 listenfd:3  
 bind successfully!  
 local IP:192.168.3.51 port:8888  
 listening....  
 connection from [127.0.0.1:45890]  
 Received message:I am client1!  
 sendmessage:I am client1!  
 connection from [192.168.3.51:35721]  
 Received message:I am client2! I am telnet  
   
 sendmessage:I am client2! I am telnet  
   
 Received message:I am client1, how are you!  
 sendmessage:I am client1, how are you!  
 client is closed  
 child(7216) is over!  
 Received message:I am telnet, I am still alive!  
   
 sendmessage:I am telnet, I am still alive!  

可以看到实现了并发！

三、I/O多路复用并发服务器

I/O多路复用模型可以解决资源限制的问题。此模型实际上时将ＵＤＰ循环模型用在了ＴＣＰ上面。服务器用单进程循环处理请求（客户端有限的情况下）。

但是，其存在同样的问题：由于服务器是依次处理客户的请求，所以可能会导致有的客户等待时间过长。

server：

[cpp] view plaincopy  
 #include <stdio.h>  
 #include <string.h>  
 #include <stdlib.h>  
 #include <unistd.h>  
 #include <sys/types.h>  
 #include <sys/socket.h>  
 #include <sys/select.h>  
 #include <netinet/in.h>  
 #include <arpa/inet.h>  
 #define PORT 8888  
 #define MAXSIZE 128  
   
 int main()  
 {  
     int i,nbyte;  
     int listenfd, confd, maxfd;  
     char buffer[MAXSIZE];  
     fd_set global_rdfs, current_rdfs;  
     struct sockaddr_in addr,clientaddr;  
     int addrlen = sizeof(struct sockaddr_in);  
     int caddrlen = sizeof(struct sockaddr_in);  
   
     if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) == -1)  
     {  
         perror("socket error");  
         exit(-1);  
     }  
     else  
     {  
         printf("socket successfully!\n");  
         printf("listenfd : %d\n",listenfd);  
     }  
   
     memset(&addr, 0 ,addrlen);  
     addr.sin_family = AF_INET;  
     addr.sin_port = htons(PORT);  
     addr.sin_addr.s_addr = htonl(INADDR_ANY);  
     if(bind(listenfd,(struct sockaddr *)&addr,addrlen) == -1)  
     {  
         perror("bind error");  
         exit(-1);  
     }  
     else  
     {  
         printf("bind successfully!\n");  
         printf("listen port:%d\n",PORT);  
     }  
   
     if(listen(listenfd,5) == -1)  
     {  
         perror("listen error");  
         exit(-1);  
     }  
     else  
     {  
         printf("listening...\n");  
     }  
   
     maxfd = listenfd;  
     FD_ZERO(&global_rdfs);  
     FD_SET(listenfd,&global_rdfs);  
   
     while(1)  
     {  
         current_rdfs = global_rdfs;  
         if(select(maxfd + 1,&current_rdfs, NULL, NULL,0) < 0)  
         {  
             perror("select error");  
             exit(-1);  
         }  
           
         for(i = 0; i <= listenfd + 1; i++)  
         {  
             if(FD_ISSET(i, &current_rdfs)) //fd 就绪  
             {  
                 if(i == listenfd) //有新的连接  
                 {  
                     if((confd = accept(listenfd,(struct sockaddr *)&clientaddr,&caddrlen)) == -1)  
                     {  
                         perror("accept error");  
                         exit(-1);  
                     }  
                     else  
                     {  
                         printf("Connect from [IP:%s PORT:%d]\n",  
                                 inet_ntoa(clientaddr.sin_addr),clientaddr.sin_port);  
                         FD_SET(confd,&global_rdfs);  
                         maxfd = (maxfd > confd ? maxfd : confd);  
                     }  
                 }  
                 else  
                 {  
                     if((nbyte = recv(i, buffer, sizeof(buffer),0)) < 0)  
                     {  
                         perror("recv error");  
                         exit(-1);  
                     }  
                     else if(nbyte == 0) //客户端close  
                     {  
                         close(i);  
                         FD_CLR(i,&global_rdfs); //将其清出  
                     }  
                     else  
                     {  
                         printf("recv:%s\n",buffer);  
                         send(i, buffer, sizeof(buffer),0);  
                     }  
                 }  
             }  
         }  
     }  
   
     return 0;  
 }  

这里使用多路连接TCP服务器，执行结果如下：

[cpp] view plaincopy  
 fs@ubuntu:~/qiang/select$ ./select  
 socket successfully!  
 listenfd : 3  
 bind error: Address already in use  
 fs@ubuntu:~/qiang/select$ ./select2  
 socket successfully!  
 listenfd : 3  
 bind successfully!  
 listen port:8888  
 listening...  
 Connect from [IP:192.168.3.51 PORT:40075]  
 recv:xiao  
   
 Connect from [IP:192.168.3.51 PORT:40331]  
 Connect from [IP:192.168.3.84 PORT:36233]  
 Connect from [IP:192.168.3.33 PORT:2499]  