select

应用程序中同时需要处理多路输入输出流。select允许同时对多个IO进行操作，内核一旦发现一个或多个IO事件发生，就会通知该进程执行select函数。

select函数阻塞等待集合中的文件描述符就绪。如果有文件描述符准备就绪，则该函数立即返回。

头文件：
    #include <sys/time.h>
    #include <sys/types.h>
    #include <unistd.h>
原型：
    int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout);
参数：
    int nfd：指定要检测的最大文件描述符+1;
    fd_set *readfds, fd_set *writefds, fd_set *exceptfds:指定让内核去检测（读、写、其他）集合中所有的文件描述符。如果对某个文件描述符集合不感兴趣，可以填NULL；
    struct timeval *timeout：设置超时时间；
        如果不想设置超时时间，可以填NULL，则该函数一直阻塞，直到有文件描述符触发事件或者出错;
返回值：
    >0，成功触发事件的文件描述符个数；
    ==0 ，超时;
    -1， 失败;
例程：
    int res = select(maxfd+1, &tempfds, NULL, NULL, NULL);
    if(res <= 0)
    {
        ERR_LOG("select");
        return -1;
    }

操控集合函数

void FD_CLR(int fd, fd_set *set);   //将fd从集合set中删除
int  FD_ISSET(int fd, fd_set *set); //判断fd是否在集合set中，如果存在返回1，不存在返回0;
void FD_SET(int fd, fd_set *set);   //将fd添加到集合set中
void FD_ZERO(fd_set *set);          //清空集合set

select模型

当有一个文件描述符触发，select会删除集合中其他文件描述符；

当有两个文件描述符同时触发，select会删除集合中除这个两个文件描述符外的其他文件描述符；

//框架
sfd = socket();
bind();
listen();
//将文件描述符添加到集合中
fd_set readfds, tempfds;
FD_SET(0, &readfds);
FD_SET(sfd, &readfds);
while(1)
{
    tempfds = readfds; 
    res = select(maxfd+1, &tempfds, NULL, NULL, NULL);
    for()//循环判断产生的事件
    {
        //键盘事件
        //连接事件（accept）
        maxfd = maxfd>newfd?maxfd:newfd;//更新最大文件描述符
        //其他事件 读取客户端数据事件
        updatemaxfd();//更新最大文件描述符
    }
}

超时时间检测

1.在网络通讯中，有很多函数是阻塞函数，使进程阻塞，例如accept recv send sendto recvform等等

2.为了避免进程在阻塞函数中无限制的阻塞，可以设置超时时间，当超时后从阻塞函数立即返回，继续运行

select函数设置超时时间

struct timeval *timeout;
struct timeval
{                      
    __time_t tv_sec;        /* Seconds.  */
    __suseconds_t tv_usec;  /* Microseconds.  */
}; 

struct timeval val;
val.tv_sec = 5;
val.tv_usec = 0;
while(1)
{   
    struct timeval val = {5, 0};                                                          
    tempfds = readfds; 
    int res = select(maxfd+1, &tempfds, NULL, NULL, &val);
    if(res < 0)
    {
        ERR_LOG("select");
        return -1; 
    }
    if(0 == res)
    {
        printf("timeout.....\n");
        continue;
    }
    for()//循环判断产生的事件
    {
        //键盘事件
        //连接事件（accept）
        maxfd = maxfd>newfd?maxfd:newfd;//更新最大文件描述符
        //其他事件 读取客户端数据事件
        updatemaxfd();//更新最大文件描述符
    }
}

select（TCP）服务器

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#define ERR_LOG(msg) do{\
    perror(msg);\
    printf("%d %s %s\n", __LINE__, __func__, __FILE__);\
}while(0)
#define N 128
#define PORT 8888
#define IP "0.0.0.0"
//char buf[N] = "";//big bug
int updatamaxfd(int maxfd,fd_set readfds);
int main(int argc, const char *argv[])
{
    //1.创建套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd < 0)
    {
        ERR_LOG("socket");
        return -1;
    }
    int value = 1;
    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &value, sizeof(int));
    //2.绑定服务器ip和端口
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(PORT);
    saddr.sin_addr.s_addr = inet_addr(IP);
    if(bind(sfd, (struct sockaddr*)&saddr, sizeof(saddr)) <0)
    {
        ERR_LOG("bind");
        return -1;
    }
    //3.将套接字设置为被动监听状态
    if(listen(sfd, 5) < 0)
    {
        ERR_LOG("listen");
        return -1;
    }
    printf("开始监听...\n");
    //4.获取连接后的套接字
    struct sockaddr_in caddr;
    socklen_t clen = sizeof(caddr);
    //申请读集合,并将0号,sfd添加到读集合中
    fd_set readfds, tempfds;
    FD_ZERO(&readfds);//resolve big bug
    FD_SET(0, &readfds);
    FD_SET(sfd, &readfds);
    int maxfd = sfd;
    char buf[N] = "";
    int newfd; 
    // int j;
    while(1)
    {
        // for(j=0;j<=maxfd;j++)
        // {
        //     printf("j=%d ", j);
        // }
        // putchar(10);
        tempfds = readfds; 
        int res = select(maxfd+1, &tempfds, NULL, NULL, NULL);
        if(res <= 0)
        {
            ERR_LOG("select");
            return -1;
        }
        int i = 0;
        for(i=0; i<=maxfd; i++)
        {
            if(FD_ISSET(i, &tempfds) == 0)
            {
                // printf("不存在的fd=%d\n", i);
                continue;
            }
            // printf("存在的fd=%d\n", i);
            if(0 == i)
            {
                //触发键盘输入事件
                while(getchar()!=10);
                int sendcfd;
                printf("请输入要发送给的客户端的fd：");
                scanf("%d",&sendcfd);
                while(getchar()!=10);
                printf("请输入要发送给客户端的信息：");
                bzero(buf,N);
                fgets(buf,N,stdin);
                buf[strlen(buf)-1] = 0;
                //send发送数据
                if(send(sendcfd,buf,strlen(buf),0) < 0)
                {
                    ERR_LOG("send");
                    return -1;
                }
            }
            else if(sfd == i)
            {
                //触发连接事件
                newfd = accept(sfd, (struct sockaddr*)&caddr, &clen);
                if(newfd < 0)
                {
                    ERR_LOG("accept");
                    return -1;
                }
                printf("newfd = %d\n", newfd);
                //将新的套接字添加到读集合中
                FD_SET(newfd, &readfds);
                //更新maxfd
                maxfd = maxfd > newfd ? maxfd : newfd;
            }
            else
            {
                //客户端交互事件
                bzero(buf, N);
                int recv_len = recv(i, buf, N, 0);
                if(recv_len < 0)
                {
                    ERR_LOG("recv");
                    close(i);
                    return -1;
                }
                else if(0 == recv_len)
                {
                    printf("fd=%d 已断开连接\n", i);
                    close(i);
                    //将文件描述符从集合中删除
                    FD_CLR(i, &readfds);
                    //更新最大文件描述符
                    maxfd = updatamaxfd(maxfd, readfds);
                }
                else
                {
                    printf("收到来自fd = %d的消息:%s\n",i,  buf);
                }
            }
        }
    }
    //关闭套接字
    close(sfd);
    return 0;
}
int updatamaxfd(int maxfd, fd_set readfds)
{
    int i = 0;
    for(i=maxfd; i>=0; i--)
    {
        if(FD_ISSET(i, &readfds))
        {
            return i;
        }
    }
    return -1;
}

演示

BUG

一个问题

解决

在定义集合后对集合进行清空操作

    fd_set readfds, tempfds;
    FD_ZERO(&readfds);//清空集合，有点类似于bzero，不清空的话，结果如下
    //申请读集合,并将0号,sfd添加到读集合中
    fd_set readfds, tempfds;
    //FD_ZERO(&readfds);//resolve big bug
    FD_SET(0, &readfds);
    FD_SET(sfd, &readfds);
    int maxfd = sfd;
    //char buf[N] = "";
    int j;
    for(j=0;j<=maxfd;j++)
    {
        if(FD_ISSET(j, &readfds) == 0)
        {
            printf("不存在的fd=%d\n", j);
            continue;
        }
        printf("存在的fd=%d\n", j);
    }
    putchar(10);
    while(1)
    {
        printf("进入循环\n");

开始监听...
存在的fd=0
存在的fd=1
不存在的fd=2
存在的fd=3

进入循环

本文链接：https://shengto.top/network_programming/select_model.html

转载时须注明出处及本声明

Last modification：2021 年 04 月 20 日 10 : 25 : 02
© 允许规范转载