IO复用——select

select

select的事件的轮训机制是基于比特位的。每次查询都要遍历整个事件列表。
每个select都要处理一个fd_set结构。fd_set简单地理解为一个长度是1024的比特位，每个比特位表示一个需要处理的FD，如果是1，那么表示这个FD有需要处理的I/O事件，否则没有。
select能处理fd最大的数量是1024，这是由fd_set的容量决定的。

select的缺点：

1. 单个进程能够监视的文件描述符的数量存在最大限制，通常是1024，当然可以更改数量，但由于select采用轮询的方式扫描文件描述符，文件描述符数量越多，性能越差；
   (在linux内核头文件中，有这样的定义：#define __FD_SETSIZE 1024)

2. 内核 / 用户空间内存拷贝问题，select需要复制大量的句柄数据结构，产生巨大的开销；

3. select返回的是含有整个句柄的数组，应用程序需要遍历整个数组才能发现哪些句柄发生了事件；

4. select的触发方式是水平触发，应用程序如果没有完成对一个已经就绪的文件描述符进行IO操作，那么之后每次select调用还是会将这些文件描述符通知进程。

相比select模型，poll使用链表保存文件描述符，因此没有了监视文件数量的限制，但其他三个缺点依然存在。

拿select模型为例，假设我们的服务器需要支持100万的并发连接，则在__FD_SETSIZE 为1024的情况下，则我们至少需要开辟1k个进程才能实现100万的并发连接。除了进程间上下文切换的时间消耗外，从内核/用户空间大量的无脑内存拷贝、数组轮询等，是系统难以承受的。因此，基于select模型的服务器程序，要达到10万级别的并发访问，是一个很难完成的任务。

因此，该epoll上场了。

epoll IO多路复用模型实现机制

由于epoll的实现机制与select/poll机制完全不同，上面所说的 select的缺点在epoll上不复存在。

设想一下如下场景：有100万个客户端同时与一个服务器进程保持着TCP连接。而每一时刻，通常只有几百上千个TCP连接是活跃的(事实上大部分场景都是这种情况)。如何实现这样的高并发？

在select/poll时代，服务器进程每次都把这100万个连接告诉操作系统(从用户态复制句柄数据结构到内核态)，让操作系统内核去查询这些套接字上是否有事件发生，轮询完后，再将句柄数据复制到用户态，让服务器应用程序轮询处理已发生的网络事件，这一过程资源消耗较大，因此，select/poll一般只能处理几千的并发连接。

epoll的设计和实现与select完全不同。epoll通过在Linux内核中申请一个简易的文件系统(文件系统一般用什么数据结构实现？红黑树)。把原先的select/poll调用分成了3个部分：

1）调用epoll_create()建立一个epoll对象(在epoll文件系统中为这个句柄对象分配资源)

2）调用epoll_ctl向epoll对象中添加这100万个连接的套接字

3）调用epoll_wait收集发生的事件的连接

如此一来，要实现上面说是的场景，只需要在进程启动时建立一个epoll对象，然后在需要的时候向这个epoll对象中添加或者删除连接。同时，epoll_wait的效率也非常高，因为调用epoll_wait时，并没有一股脑的向操作系统复制这100万个连接的句柄数据，内核也不需要去遍历全部的连接。

服务器

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

#define MAX_FD 128
#define DATALEN 1024

//初始化服务器端套接字
int InitSocket()
{
    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(6000);
    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 errno\n");
	return -1;
    }

    
    res=listen(sockfd,5);
    if(res==-1) 
    {
	printf("listen errno\n");
	return -1;
    }

    return sockfd;
}

//初始化记录服务器套接字到数组
void InitFds(int fds[],int n)
{
    int i=0;
    for(;i<n;i++)
    {
	fds[i]=-1;
    }
}

//将套接字描述符添加到数组中
void AddFdToFds(int fds[],int fd,int n)
{
    int i=0;
    for(;i<n;i++)
    {
	if(fds[i]==-1)
	{
	    fds[i]=fd;
	    break;
	}
    }
}

//删除数组中到套接字描述符
void DelFdFromFds(int fds[],int fd,int n)
{
    int i=0;
    for(;i<n;i++)
    {
	if(fds[i]==fd)
	{
	    fds[i]=-1;
	    break;
	}
    }
}

//将数组的套接字描述符设置到fd_set变量中，并返回当前最大的文件描述符值
int SetFdToFdset(fd_set *fdset,int fds[],int n)
{
    FD_ZERO(fdset);//清除fdset的所有位
    int i=0,maxfd=fds[0];
    for(;i<n;i++)
    {
	if(fds[i]!=-1)
	{
	    FD_SET(fds[i],fdset);//设置fdset的位fd
	    if(fds[i]>maxfd)
	    {
		maxfd=fds[i];
	    }
	}
    }
    return maxfd;
}

//获取客户端连接
void GetClientLink(int sockfd,int fds[],int n)
{
    struct sockaddr_in caddr;
    memset(&caddr,0,sizeof(caddr));
    socklen_t len=sizeof(caddr);
    int c =accept(sockfd,(struct sockaddr*)&caddr,&len);
    if(c<0)
    {
	return;
    }
    printf("A client is connected\n");
    AddFdToFds(fds,c,n);
}

//处理客户端数据
void DealClientData(int fds[],int n,int clifd)
{
    char data[DATALEN]={0};
    int num=recv(clifd,data,DATALEN-1,0);
    if(num<=0)
    {
	DelFdFromFds(fds,clifd,n);
	close(clifd);
	printf("A client is disconnected\n");
    }
    else
    {
	printf("%d:%s\n",clifd,data);
	send(clifd,"OK",2,0);
    }
}

//处理select返回到就绪事件
void DealReadyEvent(int fds[],int n,fd_set *fdset,int sockfd)
{
    int i=0;
    for(;i<n;i++)
    {
	if(fds[i]!=-1 && FD_ISSET(fds[i],fdset))
	{
	    if(fds[i]==sockfd)
	    {
		GetClientLink(sockfd,fds,n);
	    }
	    else
	    {
		DealClientData(fds,n,fds[i]);
	    }
	}
    }
}

int main()
{
    int sockfd=InitSocket();
    assert(sockfd!=-1);

    fd_set readfds;
    int fds[MAX_FD];
    InitFds(fds,MAX_FD);
    AddFdToFds(fds,sockfd,MAX_FD);

    while(1)
    {
	int maxfd=SetFdToFdset(&readfds,fds,MAX_FD);
	struct timeval timeout;
	timeout.tv_sec=2;//秒数
	timeout.tv_usec=0;//微秒数
	int n=select(maxfd+1,&readfds,NULL,NULL,&timeout);
	if(n<0)
	{
	    printf("select error\n");
	    break;
	}
	else if(n==0)
	{
	    printf("time out\n");
	    continue;
	}
	DealReadyEvent(fds,MAX_FD,&readfds,sockfd);
    }

    exit(0);
}