01.select、poll、select的区别
既然为每个请求分配一个进程/线程的方式不合适，使用一个进程维护多个Socket。这就是IO多路复用技术。
Select/poll、epoll内核提供给用户态的多路复用系统调用，进程可以通过一个系统调用函数从内核中获取多个事件。
Select/poll/epoll 在获取事件时，先把所有连接（文件描述符）传给内核，再由内核返回产生了事件的连接，然后在用户态再处理这些连接对应的请求。
Select/poll:将已连接的socket都放在一个文件描述符集合中，调用select函数将文件描述符集合拷贝到内核中，让内核来检查是否有网络事件发生，检查方式就是遍历文件描述符集合，当检查到有事件发生后，将此socket标记为可读或可写，接着再把整个文件描述符集合拷贝回用户态，用户态还需要再遍历找到可读或可写的socket,再对其进行处理。
缺点：对于这种方式，需要进行2次【遍历】文件描述符集合，一次在内核态，一次在用户态，还会大声2次拷贝文件描述符集合。
Select使用固定长度的BitsMap，表示文件描述符集合，默认最大值为1024，监听0~1023的文件描述符。
Poll不再使用BitsMap来存储关注的文件描述符，使用动态数组，用链表形式组织，突破了select的文件描述符个数限制。
缺点：都是使用线性结构存储进程关注的socket集合，都需要遍历文件描述符集合来找到可读或可写的socket，也需要在用户态与内核态之间拷贝文件描述符集合。
Epoll:
1.epoll在内核里使用红黑树来跟踪进程所有待检测的文件描述符，把需要监控的socket通过epoll_ctl函数加入内核中的红黑树中，红黑树增删差时间复杂度（logn）。这样每次操作时只需要传入一个待检测的socket，减少了内核和用户空间大量的数据拷贝和内存分配。
2.epoll使用事件驱动的机制，内核里维护了一个链表来记录就绪事件，当某个socket有事件发生时，通过回调函数内核会将其加入到这个就绪事件列表中，当用户调用epoll_wait()函数时，只会返回有事件发生的文件描述。
3.epoll支持两种事件触发模式，分别是边缘触发（ET），水平触发(LT)。
边缘触发模式（ET）：当被监控的socket描述符上有可读事件发生时，服务器端只会从epoll_wait中苏醒一个，即使进程没有调用read函数从内核读取数据，也依然只苏醒一次，因此程序要保证一次将内核缓冲区的数据读取完。（一般和非阻塞IO搭配使用）
水平触发模式：当被监控的socket上有可读事件发生时，服务器端不断地从epoll_wait中苏醒，直到内核缓冲区数据被read函数读完才结束，目的是告诉我们有数据需要读取。
使用IO多路复用时，最好和非阻塞IO一起使用。
1.IO多路复用简述
IO 多路复用是一种同步 IO 模型，实现一个线程可以监视多个文件句柄；一旦某个文件句柄就绪，就能够通知应用程序进行相应的读写操作；没有文件句柄就绪时会阻塞应用程序，交出 cpu。IO 是指网络 IO，多路指多个TCP连接(即 socket 或者 channel)，复用指复用一个或几个线程。意思说一个或一组线程处理多个 TCP 连接。最大优势是减少系统开销小，不必创建过多的进程/线程，也不必维护这些进程/线程。IO 多路复用的三种实现方式：select、poll、epoll。
2.select
基本原理：客户端操作服务器时就会产生这三种文件描述符(简称fd)：writefds(写)、readfds(读)、和 exceptfds(异常)。select 会阻塞住监视 3 类文件描述符，等有数据、可读、可写、出异常或超时就会返回；返回后通过遍历 fdset 整个数组来找到就绪的描述符 fd，然后进行对应的 IO 操作。
优点：
几乎在所有的平台上支持，跨平台支持性好
缺点：
1、由于是采用轮询方式全盘扫描，会随着文件描述符 FD 数量增多而性能下降。
2、每次调用 select()，都需要把 fd 集合从用户态拷贝到内核态，并进行遍历(消息传递都是从内核到用户空间)。
3、单个进程打开的 FD 是有限制(通过FD_SETSIZE设置)的，默认是 1024 个，可修改宏定义，但是效率仍然慢。
2.1select函数原型分析
#include<sys/select.h>
#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);
nfds:监控的文件描述符集合里最大文件描述符加1，因此此参数会告诉内核检测前多少个文件描述符的状态
readfds：监控有读数据到达文件描述符集合，传入传出参数
writefds：监控有写数据到达文件描述符集合，传入传出参数
exceptfds：监控异常发生的文件描述符集合，传入传出参数
timeout：定时阻塞监控时间，3种情况
1.NULL，永远等下去
2.设置timeval 等待固定时间
3.设置timeval里时间为0，检查描述字符后立即返回。
struct timeval
{
/* data */
long tv_sec;
long tv_usec;
};
void FD_CLR(int fd, fd_set *set); //把文件描述符集合里的fd清0
int FD_ISSET(int fd, fd_set *set); //测试文件描述符集合里fd是否为1
void FD_SET(int fd, fd_set *set); //把文件描述符集合里fd置为1；
void FD_ZERO(fd_set *set); //把文件描述符集合里的fd清0
返回值：事件发生的个数。
2.2select函数实现服务器
socket()函数用于创建套接字
lfd=socket(); //创建套接字
bind(); //绑定地址结构
listen(); //设置监听
fd_set rset; //创建一个读监听集合
fd_set allset;
FD_ZERO（&allset）; //将读监听集合清空
FD_SET(lfd,&allset); //将需要监听的文件描述符加入到读集合当中。
rset=allset;
while(1){
ret = select(lfd+1,&rset,NULL,NULL,NULL); //让select帮助监听。
if(ret>0)
{
//如果lfd在rset中，表示监听的文件描述符上有读事件。
if(FD_ISSET(lfd,&rset))
{
cfd=accept(); //会返回一个通信的文件描述符
FD_SET(cfd,&allset);
}
}
}
1select.c
#include<sys/select.h>
#include<sys/time.h>
#include<sys/types.h>
#include<unistd.h>
#include"wrap.h"
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
#include<pthread.h>
#include<ctype.h>
#include<fcntl.h>
#define PORT 6666
int main(int argr,char*argc[])
{
int lfd=0,cfd=0,maxfd=0;
char buf[BUFSIZ];
int len=BUFSIZ;
lfd=Socket(AF_INET,SOCK_STREAM,0);
int opt=1;
//设置端口复用
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
struct sockaddr_in serv_addr,clie_addr;
socklen_t clientlen=sizeof(clie_addr);
bzero(&serv_addr,sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_addr.sin_port=htons(PORT);
Bind(lfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
Listen(lfd,128);
//IO多路复用
maxfd=lfd; //最大文件描述符
//设置集合
fd_set allset,rset; //定义读集合，和备份集合
FD_ZERO(&allset); //清空 需要检测的集合
FD_ZERO(&rset);
//添加文件描述符
FD_SET(lfd,&allset); //将要检测的lfd添加到检测集合中
while(1)
{
rset=allset; //备份
int n=select(maxfd+1,&rset,NULL,NULL,NULL); //使用select进行检测
if(n<0)
{
perr_exit("select error");
}
if(FD_ISSET(lfd,&rset)) //说明 lfd文件描述符 有读事件 发生，
{
cfd=Accept(lfd,(struct sockaddr*)&clie_addr,&clientlen); //建立连接，此时不会阻塞
FD_SET(cfd,&allset); //将得到的通信的文件描述符加入到set集合中。
if(cfd>maxfd)
{
maxfd=cfd;
}
//说明select只返回一个，并且是listenfd，后续执行无需执行。
if(n==1)
{
continue;
}
}
//处理 满足 读事件的 通信的文件描述符fd
for(int i=lfd+1;i<maxfd+1;i++)
{
if(FD_ISSET(i,&rset)) //寻找。
{
int n=Read(i,buf,len);
//说明文件描述符已经关闭。
if(n==-1)
{
perr_exit("read error");
}else if(n==0) //检测客户端已经关闭连接了
{
Close(i);
FD_CLR(i,&allset); //将关闭的fd移除检测集合
}
for(int j=0;j<n;j++)
{
buf[j]=toupper(buf[j]);
}
write(i,buf,n);
write(STDOUT_FILENO,buf,n);
}
}
}
Close(lfd);
return 0;
}
1client.c
#include<sys/errno.h>
#include<stdio.h>
#include<unistd.h>
#include<ctype.h>
#include<string.h>
#include"wrap.h"
#define PORT 6666
int main()
{
int cfd=0;
char buf[BUFSIZ];
cfd=Socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in serv_addr;
bzero(&serv_addr,sizeof(serv_addr));
serv_addr.sin_family=AF_INET;
serv_addr.sin_port=htons(PORT);
inet_pton(AF_INET,"127.0.0.1",&serv_addr.sin_addr.s_addr);
Connect(cfd,(struct sockaddr*)&serv_addr,sizeof(serv_addr));
while(fgets(buf,BUFSIZ,stdin)!=NULL)
{
Write(cfd,buf,strlen(buf));
int n=Read(cfd,buf,BUFSIZ);
if(n==0)
{
break;
}
else write(STDOUT_FILENO,buf,n);
}
Close(cfd);
return 0;
}
编译：
gcc 1select.c wrap.c -o 1select -Wall
gcc 1client.c wrap.c -o 1client -Wall
3.poll
**基本原理：**与 select 一致，也是轮询+遍历。唯一的区别就是 poll 没有最大文件描述符限制(使用链表的方式存储 fd)。
优点
1.自带数组结构，可以将检测事件和返回事件分离，
2.可以拓展监听上限，可以超出1024个限制
poll 缺点
不能跨平台，linux
由于是采用轮询方式全盘扫描，会随着文件描述符 FD 数量增多而性能下降。
每次调用 poll ()，都需要把 fd 集合从用户态拷贝到内核态，并进行遍历(消息传递都是从内核到用户空间)。
3.1poll原型分析
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
fds : 需要检测的文件描述符[数组],传入传出数组。
struct pollfd {
int fd; /* file descriptor */ //文件描述符
short events; /* requested events */ //监听事件POLLIN，POLLOUT，POLLERR
short revents; /* returned events */ //返回的事件，传入时为0，如果满足对应事件的话，返回非0.
};
nfds：监听数组的，实际有效监听个数。监控数组中需要监控的文件描述符数量。
timeout：毫秒级等待
-1：阻塞等，
0：立即返回，不阻塞进程
0: 等待指定毫秒数，如当前系统时间精度不够毫秒，向上取整。
返回值：成功，所有检测集合中，满足条件的总数。
-1，失败。
3.2poll实现服务器
#include<sys/select.h>
#include<sys/time.h>
#include<sys/types.h>
#include<unistd.h>
#include"wrap.h"
#include<sys/socket.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
#include<pthread.h>
#include<ctype.h>
#include<fcntl.h>
#include<poll.h>
#define MAXLINE 80
#define PORT 8000
#define OPEN_MAX 1024
int main()
{
int i,j,maxi,lfd,cfd,sockfd;
int nready; //接收poll返回值，记录发生事件的文件描述符个数
ssize_t n;
char buf[MAXLINE],str[INET_ADDRSTRLEN];
socklen_t clie_len;
struct pollfd client[OPEN_MAX];
struct sockaddr_in cliaddr,servaddr;
lfd=Socket(AF_INET,SOCK_STREAM,0);
int opt=1;
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_port=htons(PORT);
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
Bind(lfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
Listen(lfd,128);
client[0].fd=lfd;
client[0].events=POLLIN;
for(int i=1;i<OPEN_MAX;i++)
{
client[i].fd=-1;
}
maxi=0;
while(1)
{
nready=poll(client,maxi+1,-1); //阻塞监听是否有客户端连接请求
if(client[0].revents & POLLIN)
{
printf("have a connect request\n");
clie_len=sizeof(cliaddr);
cfd=Accept(lfd,(struct sockaddr*)&cliaddr,&clie_len);
printf("success establishing connect request\n");
for(i=1;i<OPEN_MAX;i++)
{
if(client[i].fd<0)
{
client[i].fd=cfd; //找到client中空闲的位置，存放accept返回的cfd
client[i].events=POLLIN;
break;
}
}
if(i==OPEN_MAX) //达到了最大客户端数
{
perr_exit("too many clients");
}
if(i>maxi)
{
maxi=i; //更新client[]中最大元素下标
printf("maxi=%d\n",maxi);
}
// if(--nready<=0) //没有返回更多的就绪事件，
// {
// continue;
// }
}
printf("lfd success\n");
for(i=1;i<=maxi;i++)
{
printf("query cfd \n");
if((sockfd=client[i].fd)<0)
{
continue;
}
if(client[i].revents & POLLIN)
{
printf("have data to read\n");
if((n=Read(sockfd,buf,MAXLINE))<0)
{
if(errno==ECONNREFUSED) //受到RST标志
{
Close(sockfd);
client[i].fd=-1; //poll中不监控该文件描述符，
}
else{
perr_exit("read error");
}
}else if(n==0) //说明对端已经关闭
{
printf("read n= %ld bytes\n",n);
Close(sockfd);
client[i].fd=-1;
}else{
printf("read n bytes\n");
for(j=0;j<n;j++)
{
buf[j]=toupper(buf[j]);
}
Write(sockfd,buf,n);
Write(STDOUT_FILENO,buf,n);
}
if(--nready<=0)
{
break;
}
}
}
}
return 0;
}
关于read的用法：
>0 : 实际读到的字节数
=0：socket中，表示对端关闭，close()
-1： 如果 errno==EINTR 被异常中断，需要重启
如果 errno==EAGIN 或 EWOULDBLOCK 以非阻塞的方式读取数据，但是没有数据，需要再次读
如果 errno == ECONNRESET 说明连接被重置，需要close()，移除检测队列
其他：错误
4.epoll
基本原理：
没有 fd 个数限制，用户态拷贝到内核态只需要一次，使用事件通知机制来触发。通过 epoll_ctl 注册 fd，一旦 fd 就绪就会通过 callback 回调机制来激活对应 fd，进行相关的 io 操作。
epoll 之所以高性能是得益于它的三个函数：
epoll反应堆模型：
1、epoll_create() 系统启动时，在 Linux 内核里面申请一个B+树结构文件系统，返回 epoll 对象，也是一个 fd。
2、epoll_ctl() 每新建一个连接，都通过该函数操作 epoll 对象，在这个对象里面修改添加删除对应的连接 fd，绑定一个 callback 函数
3、epoll_wait() 轮训所有的callback集合，并完成对应的 IO 操作
优点：高效
缺点：不能跨平台，只能在linux操作系统中使用。
对比 ET 和 LT
水平触发模式（LT）：客户端写入500个字节到服务端，服务器读取300字节，然后读取剩下200字节
边沿触发模式（ET）：客户端写入500个字节到服务端，不需要全部读，只需要读200字节。
举例：属性信息，存储在文件头值中。
4.1epoll函数原型
epoll:
int epoll_create(int size)；//创建一颗用于检测的红黑树
size：创建的红黑树的检测节点数量(仅供内核参考)
返回值：指向新创建的红黑树的根节点的epfd；
-1 errno 失败
------------------------------------------------------------------------------------------------------------------------------------
int epoll_ctl(int epfd,int op,int fd,struft epoll_event*event);//操作用于检测的红黑树
epfd：epoll_create函数返回值，红黑数的根节点
op：对红黑树所做的操作
EPOLL_CTL_ADD ：将fd添加到检测的红黑树上
EPOLL_CTL_MOD：修改fd在红黑树上的检测事件
EPOLL_CTL_DEL： 将一个fd从红黑树上摘下
fd：待检测的fd
event：本质上是 struft epoll_event 结构体 的地址
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
events：EPOLLIN，EPOLLOUT，EPOLLRDHUP，对fd所要检测的事件。
data： 联合体；
typedef union epoll_data {
void *ptr; //回调函数，程序运行到这里，自动调用回调函数。
int fd; //对应检测事件的fd
uint32_t u32;
uint64_t u64;
} epoll_data_t;
返回值：成功0，失败-1 ，errno
--------------------------------------------------------------------------------------------------------------------------
//阻塞监听
int epoll_wait(int epfd, struct epoll_event *events,
int maxevents, int timeout);
epfd：epoll_create函数的返回值，
events：传出参数【数组】，满足检测事件的fd的结构体
maxevents：数组，元素总个数1024
struct epoll_event events[1024]
timeout：
-1：阻塞
0：不阻塞
>0:超时时间
返回值：
>0 ：满足监听的总个数，可以用作循环上限
0：没有fd满足监听事件。
-1：失败
4.2epoll实现服务器
#include<sys/select.h>
#include<sys/time.h>
#include<sys/types.h>
#include<unistd.h>
#include"wrap.h"
#include<sys/socket.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
#include<pthread.h>
#include<ctype.h>
#include<fcntl.h>
#include<sys/epoll.h>
#define MAXLINE 80
#define PORT 8000
#define OPEN_MAX 1024
int main()
{
int i,lfd,cfd,sockfd;
int n,num=0;
ssize_t nready,efd,res;
char buf[MAXLINE],str[INET_ADDRSTRLEN];
socklen_t clie_len;
struct sockaddr_in cliaddr,servaddr;
struct epoll_event tep,ep[OPEN_MAX];
lfd=Socket(AF_INET,SOCK_STREAM,0);
int opt=1;
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_port=htons(PORT);
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
Bind(lfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
Listen(lfd,128);
efd=epoll_create(OPEN_MAX); //创建epoll红黑树，efd指向红黑树根节点
if(efd==-1)
{
perr_exit("epoll create error");
}
tep.events=EPOLLIN; //指定 lfd 的监听事件为读。
tep.data.fd=lfd;
res=epoll_ctl(efd,EPOLL_CTL_ADD,lfd,&tep); //将lfd及对应的结构体设置到树上，efd可找到该树。
if(res==-1)
{
perr_exit("epoll_ctl error");
}
while(1)
{
//epoll为server阻塞监听事件，ep为struct epoll_event 类型数组，open_max为数组容量，-1表示永久阻塞
nready=epoll_wait(efd,ep,OPEN_MAX,-1);
if(nready==-1)
{
perr_exit("epoll_wait error");
}
for(i=0;i<nready;i++)
{
if(!(ep[i].events & EPOLLIN)) //如果不是读事件，继续循环
{
continue;
}
if(ep[i].data.fd==lfd)
{
clie_len=sizeof(cliaddr);
cfd=Accept(lfd,(struct sockaddr*)&cliaddr,&clie_len);
printf("received from %s at port %d\n",inet_ntop(AF_INET,&cliaddr.sin_addr.s_addr,str,sizeof(str)),ntohs(cliaddr.sin_port));
printf("cfd %d --- client %d\n",cfd,++num);
tep.events=EPOLLIN;
tep.data.fd=cfd;
res=epoll_ctl(efd,EPOLL_CTL_ADD,cfd,&tep);
if(res==-1)
{
perr_exit("epoll ctl error");
}
}
else{
sockfd=ep[i].data.fd;
n=Read(sockfd,buf,MAXLINE);
if(n==0)
{
res=epoll_ctl(efd,EPOLL_CTL_DEL,sockfd,NULL);
if(res==1)
{
perr_exit("epoll_ctl error");
}
Close(sockfd);
printf("client [%d] closed connection \n",sockfd);
}else if(n<0)
{
perror("read n<0 error:");
res=epoll_ctl(efd,EPOLL_CTL_DEL,sockfd,NULL);
Close(sockfd);
}
else{
for(i=0;i<n;i++)
{
buf[i]=toupper(buf[i]);
}
Write(STDOUT_FILENO,buf,n);
Write(sockfd,buf,n);
}
}
}
}
Close(lfd);
}
4.3ET和LT模式
ET模式，边沿触发：
缓冲区剩余未读尽的数据不会导致epoll_wait返回。
新的事件满足时，才会触发。
LT模式，水平触发：
缓冲区剩余未读尽的数据会导致epoll_wait返回。
//边沿触发模式
#include<sys/epoll.h>
#include<stdlib.h>
#include<stdio.h>
#include<errno.h>
#include<unistd.h>
#define MAXLINE 10
int main(int argc,char *argv[])
{
int efd,i;
int pfd[2];
pid_t pid;
char buf[MAXLINE],ch='a';
pipe(pfd);
pid=fork();
//子进程 写数据
if(pid==0)
{
close(pfd[0]);
while(1)
{
for(i=0;i<MAXLINE/2;i++)
{
buf[i]=ch;
}
buf[i-1]='\n';
ch++;
for(;i<MAXLINE;i++)
{
buf[i]=ch;
}
buf[i-1]='\n';
ch++;
write(pfd[1],buf,sizeof(buf));
sleep(5);
}
close(pfd[1]);
}else if(pid>0)
{
struct epoll_event event;
struct epoll_event revent[10];
int res,len;
close(pfd[1]);
efd=epoll_create(10);
event.data.fd=pfd[0];
event.events=EPOLLIN|EPOLLET; //ET边沿触发模式
//event.events=EPOLLIN; //LT水平触发模式
epoll_ctl(efd,EPOLL_CTL_ADD,pfd[0],&event);
while(1)
{
res=epoll_wait(efd,revent,10,-1);
printf("res = %d\n",res);
if(revent[0].data.fd==pfd[0])
{
len=read(pfd[0],buf,MAXLINE/2);
write(STDOUT_FILENO,buf,len);
}
}
close(pfd[0]);
close(efd);
}else{
perror("fork");
exit(-1);
}
}
4.4epoll的ET非阻塞模式
epoll的ET模式，高效模式，但是只支持非阻塞模式。
readn调用的阻塞，比如设定读500个字符，但是只读到498，完事儿阻塞了，等另剩下的2个字符，然而在server代码里，一旦read变为readn阻塞了，进程就会阻塞在readn函数上，因为epoll_wait因为readn的阻塞不会循环执行，读不到新数据。有点死锁的意思，差俩字符所以阻塞，因为阻塞，读不到新字符。
如果将通信的文件描述符设置为非阻塞，就不会阻塞在readn函数上，等有数据重新进来了，epoll_wait重新触发，重新readn。
#include<sys/select.h>
#include<sys/time.h>
#include<sys/types.h>
#include<unistd.h>
#include"wrap.h"
#include<sys/socket.h>
#include<stdio.h>
#include<string.h>
#include<arpa/inet.h>
#include<pthread.h>
#include<ctype.h>
#include<fcntl.h>
#include<sys/epoll.h>
#define MAXLINE 80
#define PORT 8000
int main()
{
int i,lfd,cfd,sockfd;
int n,num=0;
int flag;
ssize_t nready,efd,res;
char buf[MAXLINE],str[INET_ADDRSTRLEN];
struct sockaddr_in cliaddr,servaddr;
socklen_t clie_len;
clie_len=sizeof(cliaddr);
lfd=Socket(AF_INET,SOCK_STREAM,0);
int opt=1;
setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_port=htons(PORT);
servaddr.sin_family=AF_INET;
servaddr.sin_addr.s_addr=htonl(INADDR_ANY);
Bind(lfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
Listen(lfd,128);
///
struct epoll_event event; //ctl添加事件到红黑树中
struct epoll_event res_event[10]; //wait,返回检测到发生的事件
int res,len;
efd=epoll_create(10); //创建一颗红黑树
cfd=Accept(lfd,(struct sockaddr*)&cliaddr,&clie_len);
//读数据非阻塞。套接字文件描述符设置为非阻塞状态
flag=fcntl(cfd,F_GETFL); //修改cfd为非阻塞读
flag|=O_NONBLOCK;
fcntl(cfd,F_SETFL,flag);
//构建节点
event.data.fd=cfd;
event.events=EPOLLIN|EPOLLET; //ET边沿触发，默认是水平触发
epoll_ctl(efd,EPOLL_CTL_ADD,cfd,&event); //将节点添加到红黑树上
while(1)
{
printf("epoll_wait begin\n");
res=epoll_wait(efd,res_event,10,-1); //最多10个，非阻塞监听。
printf("epoll_wait end res %d\n",res);
if(res_event[0].data.fd==cfd)
{
//读到数据了才会一直读，
while((len=read(cfd,buf,MAXLINE/2))>0)
{
write(STDOUT_FILENO,buf,len);
}
}
}
return 0;
}
4.5epoll反应堆
epoll反应堆模型 ：ET模型+非阻塞+void*ptr，自动调用回调函数
event：本质上是 struft epoll_event 结构体 的地址
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
events：EPOLLIN，EPOLLOUT，EPOLLRDHUP，对fd所要检测的事件。
data： 联合体；(共同体)
typedef union epoll_data {
void *ptr; //
int fd; //对应检测事件的fd
uint32_t u32;
uint64_t u64;
} epoll_data_t;
联合体：共同体，共同使用一块内存空间。可以用ptr取代fd。
struct evt{
int fd;
void (*func)(int a);//回调函数
}*ptr;
回调函数：满足的时候自动调用。
原来：
socket bind listen –
epoll_create 创建检测 红黑树 – 返回 epfd（红黑树的根节点） –
epoll_ctl()向树上添加一个需要检测的fd –
epoll_wait检测事件 – 检测的fd有事件产生 – 返回 有事件发生的数组 – 判断返回数组中的fd，–
如果是lfd满足 – Accpet –
如果是cfd满足 – read() – 小->大 – write回去。
**反应堆：**不仅要监听cfd的读事件，还要监听cfd的写事件。
epoll反应堆模型 ：ET模型+非阻塞、轮询+void*ptr，自动调用回调函数
socket bind listen –
epoll_create 创建检测 红黑树 – 返回 epfd（红黑树的根节点） –
epoll_ctl()向树上添加一个需要检测的fd –
epoll_wait检测事件 – 对应检测的fd有事件产生 – 返回 有事件发生的数组 –
如果是lfd满足 – Accpet –
如果是cfd满足 – read() – 小->大 –
将cfd从检测的红黑树上摘下 -- 检测epollout -- 回调函数 -- 调用epoll_ctl(ADD)重新放到红黑树上监听写事件 -- 等待epoll_wait返回 -- 说明cfd可写 – write回去 – （epoll_ctl()函数检测 cfd 的写事件）
将cfd从检测的红黑树上摘下 – – 检测epollin – epoll_wait监听-- 调用epoll_ctl(ADD)重新放到红黑树上监听读事件（epoll_ctl()函数检测 cfd 的读事件 ）
/*
*epoll基于非阻塞I/O事件驱动，反应堆模型
*/
/*
*epoll基于非阻塞I/O事件驱动，反应堆模型
*/
#include <stdio.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#define MAX_EVENTS 1024 //监听上限数
#define BUFLEN 4096
#define SERV_PORT 8080
void recvdata(int fd, int events, void *arg);
void senddata(int fd, int events, void *arg);
/* 描述就绪文件描述符相关信息 */
//void *ptr里就是传的这个结构，
struct myevent_s {
int fd; //要监听的文件描述符
int events; //对应的监听事件
void *arg; //泛型参数
void (*call_back)(int fd, int events, void *arg); //回调函数
int status; //是否在监听:1->在红黑树上(监听), 0->不在(不监听)
char buf[BUFLEN];
int len;
long last_active; //记录每次加入红黑树 g_efd 的时间值
};
int g_efd; //全局变量, 保存epoll_create返回的文件描述符
struct myevent_s g_events[MAX_EVENTS+1]; //自定义结构体类型数组. +1-->listen fd
/*将结构体 myevent_s 成员变量 初始化*/
//eventset(&g_events[MAX_EVENTS], lfd, acceptconn, &g_events[MAX_EVENTS]);
void eventset(struct myevent_s *ev, int fd, void (*call_back)(int, int, void *), void *arg)
{
ev->fd = fd;
ev->call_back = call_back;
ev->events = 0; //这个阶段还未初始化。
ev->arg = arg;
ev->status = 0; //状态信息，是否在监听树上。
memset(ev->buf, 0, sizeof(ev->buf)); //buf进行初始化。
ev->len = 0;
ev->last_active = time(NULL); //调用eventset函数的时间
return;
}
/* 向 epoll监听的红黑树 添加一个 文件描述符 */
//eventadd(efd, EPOLLIN, &g_events[MAX_EVENTS]); //
void eventadd(int efd, int events, struct myevent_s *ev)
{
struct epoll_event epv = {0, {0}};
int op;
epv.data.ptr = ev;
epv.events = ev->events = events; //EPOLLIN 或 EPOLLOUT
if (ev->status == 0) { //已经在红黑树 g_efd 里
op = EPOLL_CTL_ADD; //将其加入红黑树 g_efd, 并将status置1
ev->status = 1;
}
if (epoll_ctl(efd, op, ev->fd, &epv) < 0) //实际添加/修改
printf("event add failed [fd=%d], events[%d]\n", ev->fd, events);
else
printf("event add OK [fd=%d], op=%d, events[%0X]\n", ev->fd, op, events);
return ;
}
/* 从epoll 监听的 红黑树中删除一个 文件描述符*/
void eventdel(int efd, struct myevent_s *ev)
{
struct epoll_event epv = {0, {0}};
if (ev->status != 1) //不在红黑树上
return ;
//epv.data.ptr = ev;
epv.data.ptr = NULL;
ev->status = 0; //修改状态
epoll_ctl(efd, EPOLL_CTL_DEL, ev->fd, &epv); //从红黑树 efd 上将 ev->fd 摘除
return ;
}
/* 当有文件描述符就绪, epoll返回, 调用该函数 与客户端建立链接 */
void acceptconn(int lfd, int events, void *arg)
{
struct sockaddr_in cin; //要连接的客户端的地址结构
socklen_t len = sizeof(cin);
int cfd, i;
if ((cfd = accept(lfd, (struct sockaddr *)&cin, &len)) == -1) {
if (errno != EAGAIN && errno != EINTR) {
/* 暂时不做出错处理 */
}
printf("%s: accept, %s\n", __func__, strerror(errno));
return ;
}
do {
for (i = 0; i < MAX_EVENTS; i++) //从全局数组g_events中找一个空闲元素
if (g_events[i].status == 0) //寻找一个空闲的 //类似于select中找值为-1的元素
break; //跳出 for
if (i == MAX_EVENTS) {
printf("%s: max connect limit[%d]\n", __func__, MAX_EVENTS);//__func__：当前函数的名字 __LINE__行号
break; //跳出do while(0) 不执行后续代码
}
int flag = 0;
if ((flag = fcntl(cfd, F_SETFL, O_NONBLOCK)) < 0) { //将cfd也设置为非阻塞
printf("%s: fcntl nonblocking failed, %s\n", __func__, strerror(errno));
break;
}
/* 给cfd设置一个 myevent_s 结构体, 回调函数 设置为 recvdata */
eventset(&g_events[i], cfd, recvdata, &g_events[i]);
eventadd(g_efd, EPOLLIN, &g_events[i]); //将cfd添加到红黑树g_efd中,监听读事件
} while(0);
printf("new connect [%s:%d][time:%ld], pos[%d]\n",
inet_ntoa(cin.sin_addr), ntohs(cin.sin_port), g_events[i].last_active, i);
return ;
}
//read -- recv；read应用场景更加广泛，recv只能应用于网络
//write -- send;
void recvdata(int fd, int events, void *arg)
{
struct myevent_s *ev = (struct myevent_s *)arg;
int len;
//recv参数： flag==0 相当于read函数。
len = recv(fd, ev->buf, sizeof(ev->buf), 0); //读文件描述符, 数据存入myevent_s成员buf中
eventdel(g_efd, ev); //将该节点从红黑树上摘除
if (len > 0) {
ev->len = len;
ev->buf[len] = '\0'; //手动添加字符串结束标记
printf("C[%d]:%s\n", fd, ev->buf);
eventset(ev, fd, senddata, ev); //设置该 fd 对应的回调函数为 senddata
eventadd(g_efd, EPOLLOUT, ev); //将fd加入红黑树g_efd中,监听其写事件
} else if (len == 0) {
close(ev->fd);
/* ev-g_events 地址相减得到偏移元素位置 */
printf("[fd=%d] pos[%ld], closed\n", fd, ev-g_events);
} else {
close(ev->fd);
printf("recv[fd=%d] error[%d]:%s\n", fd, errno, strerror(errno));
}
return;
}
void senddata(int fd, int events, void *arg)
{
struct myevent_s *ev = (struct myevent_s *)arg;
int len;
len = send(fd, ev->buf, ev->len, 0); //直接将数据 回写给客户端。未作处理
eventdel(g_efd, ev); //从红黑树g_efd中移除
if (len > 0) {
printf("send[fd=%d], [%d]%s\n", fd, len, ev->buf);
eventset(ev, fd, recvdata, ev); //将该fd的 回调函数改为 recvdata
eventadd(g_efd, EPOLLIN, ev); //从新添加到红黑树上， 设为监听读事件
} else {
close(ev->fd); //关闭链接
printf("send[fd=%d] error %s\n", fd, strerror(errno));
}
return ;
}
/*创建 socket, 初始化lfd */
void initlistensocket(int efd, short port)
{
struct sockaddr_in sin;
int lfd = socket(AF_INET, SOCK_STREAM, 0);
fcntl(lfd, F_SETFL, O_NONBLOCK); //将socket设为非阻塞
memset(&sin, 0, sizeof(sin)); //bzero(&sin, sizeof(sin))
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = htons(port);
bind(lfd, (struct sockaddr *)&sin, sizeof(sin));
listen(lfd, 20);
/* void eventset(struct myevent_s *ev, int fd, void (*call_back)(int, int, void *), void *arg); */
eventset(&g_events[MAX_EVENTS], lfd, acceptconn, &g_events[MAX_EVENTS]);
//最后一个参数和第一个参数相同，回调函数在调用的时候，将本身作为参数传入。
//设置回调函数，lfd --> acceptconn
// cfd --> revdata()
/* void eventadd(int efd, int events, struct myevent_s *ev) */
eventadd(efd, EPOLLIN, &g_events[MAX_EVENTS]); // 将lfd添加到efp黑红树中。
//将一个fd 添加到红黑树上，设置监听 read事件，还是监听 write事件。
return ;
}
int main(int argc, char *argv[])
{
unsigned short port = SERV_PORT;
if (argc == 2)
port = atoi(argv[1]); //使用用户指定端口.如未指定,用默认端口
g_efd = epoll_create(MAX_EVENTS+1); //创建红黑树,返回给全局 g_efd
if (g_efd <= 0)
printf("create efd in %s err %s\n", __func__, strerror(errno));
initlistensocket(g_efd, port); //初始化监听socket
struct epoll_event events[MAX_EVENTS+1]; //保存已经满足就绪事件的文件描述符数组
printf("server running:port[%d]\n", port);
int checkpos = 0, i;
while (1) {
/* 超时验证，每次测试100个链接，不测试listenfd 当客户端60秒内没有和服务器通信，则关闭此客户端链接 */
long now = time(NULL); //当前时间
for (i = 0; i < 100; i++, checkpos++) { //一次循环检测100个。 使用checkpos控制检测对象
if (checkpos == MAX_EVENTS)
checkpos = 0;
if (g_events[checkpos].status != 1) //不在红黑树 g_efd 上
continue;
long duration = now - g_events[checkpos].last_active; //客户端不活跃的世间
if (duration >= 60) {
close(g_events[checkpos].fd); //关闭与该客户端链接
printf("[fd=%d] timeout\n", g_events[checkpos].fd);
eventdel(g_efd, &g_events[checkpos]); //将该客户端 从红黑树 g_efd移除
}
}
/*监听红黑树g_efd, 将满足的事件的文件描述符加至events数组中, 1秒没有事件满足, 返回 0*/
int nfd = epoll_wait(g_efd, events, MAX_EVENTS+1, 1000);
if (nfd < 0) {
printf("epoll_wait error, exit\n");
break;
}
for (i = 0; i < nfd; i++) {
/*使用自定义结构体myevent_s类型指针, 接收 联合体data的void *ptr成员*/
struct myevent_s *ev = (struct myevent_s *)events[i].data.ptr; //名字太长了，这一步只是换个名字
//event.events=EPOLLIN|EPOLLET; //ET边沿触发模式
//event.events=EPOLLIN; //LT水平触发模式
//epoll中如何指定监听读事件还是写事件
//EPOLLIN：表示对应的文件描述符可读(包括对端socket正常关闭)。EPOLLOUT:表示对应的文件描述符可写
if ((events[i].events & EPOLLIN) && (ev->events & EPOLLIN)) { //读就绪事件
ev->call_back(ev->fd, events[i].events, ev->arg); //就是这里才调用回调函数的？？？
//lfd EPOLLIN 将回调函数需要的参数传入。
}
if ((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT)) { //写就绪事件
ev->call_back(ev->fd, events[i].events, ev->arg);
}
}
}
/* 退出前释放所有资源 */
return 0;
}
1137
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
