101-Linux_I/O复用方法之select

1.select系统调用的作用

在一段指定时间内，监听用户感兴趣的文件描述符的可读、可写和异常等事件

2.select系统调用的原型

#include <sys/select.h>
int select(int maxfd, fd_set readfds, fd_setwritefds, fd_set *exceptfds, struct timeval *timeout);

select 成功时返回就绪(可读、可写和异常)文件描述符的总数。如果在超时时间内没有任何文件描述符就绪，select 将返回 0。select 失败是返回-1.如果在 select 等待期间，程序接收到信号，则 select 立即返回-1，并设置 errno 为 EINTR。
maxfd 参数指定的被监听的文件描述符的总数。它通常被设置为 select 监听的所有文件描述符中的最大值+1
readfds、writefds 和 exceptfds 参数分别指向可读、可写和异常等事件对应的文件描述符集合。应用程序调用 select 函数时，通过这 3 个参数传入自己感兴趣的文件
描述符。select 返回时，内核将修改它们来通知应用程序哪些文件描述符已经就绪fd_set 结构如下：

#define __FD_SETSIZE 1024
typedef long int __fd_mask;
#define __NFDBITS (8 * (int) sizeof (__fd_mask))
typedef struct
 {
 #ifdef __USE_XOPEN
 __fd_mask fds_bits[__FD_SETSIZE / __NFDBITS];
# define __FDS_BITS(set) ((set)->fds_bits)
#else
__fd_mask __fds_bits[__FD_SETSIZE / __NFDBITS];
 # define __FDS_BITS(set) ((set)->__fds_bits)
 #endif
} fd_set;
通过下列宏可以访问 fd_set 结构中的位：
 FD_ZERO(fd_set *fdset); // 清除 fdset 的所有位
FD_SET(int fd, fd_set *fdset); // 设置 fdset 的位 fd
 FD_CLR(int fd, fd_set *fdset); // 清除 fdset 的位 fd
 int FD_ISSET(int fd, fd_set *fdset);// 测试 fdset 的位 fd 是否被设置timeout 参数用来设置 select 函数的超时时间。它是一个 timeval 结构类型的指针，采用指针参数是因为内核将修改它以告诉应用程序 select 等待了多久。timeval
结构的定义如下：
struct timeval
{
 long tv_sec; //秒数
 long tv_usec; // 微秒数
};
//如果给 timeout 的两个成员都是 0，则 select 将立即返回。如果 timeout 传递NULL，则 select 将一直阻塞，直到某个文件描述符就绪

3.集合fdset

4.使用select实现TCP服务器

(1)服务器端代码:

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

#define MAXFD 10
int socket_init();
int accept_client(int sockfd);
void fds_init(int fds[])
{
    for(int i=0;i<MAXFD;i++)
    {
        fds[i]=-1;
    }
}

void fds_add(int fd,int fds[])
{
    for(int i=0;i<MAXFD;i++)
    {
        if(fds[i]==-1)
        {
            fds[i]=fd;
            break;
        }
    }
}

void fds_del(int fd,int fds[])
{
    for(int i=0;i<MAXFD;i++)
    {
        if(fds[i]==fd)
        {
            fds[i]=-1;
            break;
        }
    }
}

int main()
{
    int fds[MAXFD];//记录描述符
    fds_init(fds);
        
    int sockfd=socket_init();//监听套接字
    if(sockfd==-1)
    {
        exit(0);
    }

    fds_add(sockfd,fds);

    fd_set fdset;//集合收集描述符

    while(1)
    {
        FD_ZERO(&fdset);
        int maxfd=-1;

        for(int i=0;i<MAXFD;i++)
        {
            if(fds[i]==-1)
            {
                continue;
            }
            FD_SET(fds[i],&fdset);//将数组中有效的描述符添加到集合
            if(fds[i]>maxfd)
            {
                maxfd=fds[i];
            }
        }
        struct timeval tv={5,0};

        int n=select(maxfd+1,&fdset,NULL,NULL,&tv);//阻塞
        if(n==-1)
        {
            printf("select error\n");
        }
        else if(n==0)
        {
            printf("time out\n");
        }
        else
        {
            for(int i=0;i<MAXFD;i++)
            {
                if(fds[i]==-1)
                {
                    continue;
                }
                if(FD_ISSET(fds[i],&fdset))
                {
                    if(fds[i]==sockfd)//监听套接字,用accept处理
                    {
                        int c=accept_client(sockfd);
                        if(c!=-1)
                        {
                            fds_add(c,fds);//添加新接收的连接
                        }
                    }
                    else//recv
                    {
                        char buff[128]={0};
                        int num=recv(fds[i],buff,127,0);
                        if(num<=0)
                        {
                            close(fds[i]);
                            fds_del(fds[i],fds);
                        }
                        else

                        {
                            printf("recv:%s\n",buff);
                            send(fds[i],"ok",2,0);
                        }
                    }

                }

            }
        }

    }
}
int socket_init()
{
    int sockfd=socket(AF_INET,SOCK_STREAM,0);
    if(sockfd==-1)
    {
        return -1;
    }

    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(5678);
    saddr.sin_addr.s_addr=inet_addr("127.0.0.1");
    int res=bind(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(res==-1)
    {
        printf("bind error\n");
        return -1;
    }

    res=listen(sockfd,5);
    if(res==-1)
    {
        return -1;
    }

    return sockfd;
}
int accept_client(int sockfd)
{
    struct sockaddr_in caddr;
    int len=sizeof(caddr);
    int c=accept(sockfd,(struct sockaddr*)&caddr,&len);
    return c;
}

(2)客户端代码

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

int socket_init();

int main()
{
    int sockfd=socket_init();
    if(sockfd==-1)
    {
        exit(0);
    }

    while(1)
    {
        printf("input:");
        char buff[128]={0}; 
        fgets(buff,127,stdin);
        if(strncmp(buff,"end",3)==0)
        {
            break;
        }
        send(sockfd,buff,strlen(buff)-1,0);

        memset(buff,0,128);
        recv(sockfd,buff,127,0);
        printf("read:%s\n",buff);
    }
    close(sockfd);
    exit(0);
        
}

int socket_init()
{
    int sockfd=socket(AF_INET,SOCK_STREAM,0);//tcp流式服务
    if(sockfd==-1)
    {
        printf("socket errror\n");
        return -1;
    }

    struct sockaddr_in saddr;
    memset(&saddr,0,sizeof(saddr));    saddr.sin_family=AF_INET;
    saddr.sin_port=htons(5678);
    saddr.sin_addr.s_addr=inet_addr("127.0.0.1");


    int res=connect(sockfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(res==-1)
    {
        printf("connect error\n");
        return -1;
    }

    return sockfd;
}

(3)运行结果截图