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

最新推荐文章于 2024-04-22 21:48:59 发布

玛丽奥ZJY

最新推荐文章于 2024-04-22 21:48:59 发布

阅读量165

点赞数

分类专栏：【linux 网络编程】

【linux 网络编程】专栏收录该内容

50 篇文章 4 订阅

订阅专栏

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

循环服务器模型是指服务器端依次处理每个客户端，直到当前客户端的所有请求处理完毕，再处理下一个客户端。这类模型的优点是简单，缺点显而易见。特别是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]  

玛丽奥ZJY

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Linux 系统应用编程——网络编程（服务器模型）

在网络通信过程中，服务端通常需要处理多个客户端。由于多个客户端的请求可能会同时到来，服务器端可采用不同的方法来处理。总体上来说，服务器端可采用两种模型来实现：循环服务器模型和并发服务器模型。循环服务器模型是指服务器端依次处理每个客户端，直到当前客户端的所有请求处理完毕，再处理下一个客户端。这类模型的优点是简单，缺点显而易见。特别是TCP循环服务器模型，由于必须先处理完当前客户端，容...
复制链接

扫一扫

专栏目录