多路复用函数 select() 在 C/S 中的应用实例

beyes

服务器端代码：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
    int server_sockfd, client_sockfd;
    int server_len, client_len;
    struct sockaddr_in server_address;
    struct sockaddr_in client_address;
    int result;
    fd_set readfds, testfds;

    /*创建套接字:IPv4, tcp流套接字*/
    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
   
    server_address.sin_family = AF_INET;
    /*INADDR_ANY代表本机IP,htonl将其转换为网络字节顺序(大端模式)*/
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);
   
    server_address.sin_port = htons(9734);
    server_len = sizeof(server_address);

    /*将端口与套接字绑定*/
    bind(server_sockfd, (struct sockaddr *)&server_address, server_len);
   
    /*监听,可接受5个连接请求*/
    listen(server_sockfd, 5);
    FD_ZERO(&readfds);
    FD_SET(server_sockfd, &readfds);

    /*等待客户端请求*/
    while(1) {
        char ch;
        int  fd;
        int  nread;

        testfds = readfds;
       
        /*服务器在select后等待客户端的请求(服务器阻塞)*/   
        printf("server waiting\n");
        result = select(FD_SETSIZE, &testfds, (fd_set *)0,
                (fd_set *)0, (struct timeval *)0);

        if (result < 1) {
            perror("server");
            exit(1);
        }
        /*轮询,实际程序不使用这种极度耗时的方法*/
        for (fd = 0; fd < FD_SETSIZE; fd++) {
                if (FD_ISSET(fd, &testfds)) {
                if (fd == server_sockfd) {   
                    client_len = sizeof(client_address);
                    client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_address,
                                   &client_len);                    /*接收客户端连接请求,并返回连接套接字用于收发数据*/
                    FD_SET(client_sockfd, &readfds);    /*需要监视发来请求的客户端*/
                    printf("adding client on fd %d\n", client_sockfd);
                } else {                                                           /*客户端发生“状况”*/
                    ioctl(fd, FIONREAD, &nread);      

                    if (nread == 0) {                                  
                        close(fd);                                        /*读取不到任何内容,关闭与客户端的连接套接字*/

                        FD_CLR(fd, &readfds);              /*清除客户端套接字描述符,不再对其"关注"*/
                        printf("removing client on fd %d\n", fd);
                    } else {
                        read(fd, &ch, 1);
                        sleep(5);
                        printf("serving client on fd %d\n", fd);
                        ch++;
                        write(fd, &ch, 1);
                    }
                }
            }
        }
    }
}

---

客户端代码：

#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>

int main()
{
    int sockfd;
    int len;
    struct sockaddr_in address;
    int result;
    char ch = 'A';

    sockfd = socket(AF_INET, SOCK_STREAM, 0);
   
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = inet_addr("192.168.2.100");
    address.sin_port = htons(9734);
    len = sizeof(address);
   
    result = connect(sockfd, (struct sockaddr *)&address, len);

    if (result == -1) {
        perror("oops: client");
        exit(1);
    }
    while(1) {
        write(sockfd, &ch ,1);
        read(sockfd, &ch, 1);
        printf("char from server = %c\n", ch);
        sleep(3);
    }
}

---

说明：
实验环境用了局域网中两台装有 linux 系统的 PC ，一台作为服务器端，IP 为 192.168.2.100 ，服务器端绑定端口 9734 。
客户端程序在 connect() 与服务器端建立连接，与服务器的读写采取同步通信方式(读写被阻塞)。在这种通信方式下，如果服务器端正常运行，则会依次对每个服务器端发出的请求进行服务；如果服务器在运行的中途被中断，那么客户端会检测到与服务器的连接断开而自动退出。

服务器端状态：

beyes@linux-beyes:~/C/network> ./server.exe
server waiting
adding client on fd 4
server waiting
serving client on fd 4
server waiting
adding client on fd 5
server waiting
serving client on fd 5
server waiting
serving client on fd 4
server waiting
serving client on fd 5
server waiting
serving client on fd 4
server waiting
serving client on fd 5
server waiting
serving client on fd 4
server waiting
serving client on fd 5
server waiting
serving client on fd 4
server waiting
serving client on fd 5
server waiting
serving client on fd 4
server waiting
^C           /*按下 ctrl+c 中断服务器*/

客户端-1：

[beyes@localhost linux-c]$ ./client.exe
char from server = B
char from server = C
char from server = D
char from server = E
char from server = F
char from server = G
char from server = G

客户端-2：

[beyes@localhost linux-c]$ ./client.exe
char from server = B
char from server = C
char from server = D
char from server = E
char from server = F
char from server = F
char from server = F

由客户端的输出状态注意到(加亮部分)，在服务器端被中断后有，几个输出都是相同的。也就是说，服务器端消失后，客户端不再处于被阻塞状态，而会直接读取上次存入变量 ch 中的值，直到系统将其注销为止。这种状况，如果去掉 sleep(3); 这条语句会显得更加明显(其中可能会看到某个客户端会以刷屏的方式输出最后一行的内容，直到其被系统结束其进程)。在开启两个客户端做实验时，如果先断掉服务器，则会看到有一个客户端会“疯狂”输出最后一行内容(一般为先运行的客户端)，而另外一个客户端只是输出少数的几行。由此可推想，阻塞机制是否也是一个“赠送”时间片的过程呢 ? 也就是说，进程会每隔一段时间检测一下自己的“阻塞”状态，如果服务器端存在(阻塞条件满足)，那么自己在读不到数据时被阻塞；如果发现自己的受阻塞的条件消失了，那么将不再受到阻塞，以致于会做出那种疯狂的举动。同时，系统也会每隔一段时间检测相关(都进行一个服务器连接的进程都被等同看到为相关客户端进程)进程的状况，如果发现进程的连接条件消失(这里针对上面的网络程序而言)，那么就会结束进程。基于此，便可解释为什么先运行的客户端会刷屏，而后运行的客户端则只会输出寥寥相同的几行了。因为后来运行的客户端在属于自己的时间片时间里，检测到自己属于非阻塞状态时，也想做出刷屏的举动，但与此同时，系统已经检测到客户端1的不正常状况将其进程结束后，马上检测到相关的客户端2进程，于是也立即将其结束，所以，后来运行的客户端2很快就结束了。