epoll学习（二）

时间 2019-11-19

标签 epoll 学习繁體版

原文原文链接

首先看程序一，这个程序想要实现的功能是当用户从控制台有任何输入操做时，输出”hello world！”。ios

l 程序一数组

 1     #include <unistd.h>
 2     #include <iostream>
 3     #include <sys/epoll.h>
 4     using namespace std;
 5     int main(void)
 6     {
 7         int epfd,nfds;
 8         struct epoll_event ev,events[5];//ev用于注册事件，数组用于返回要处理的事件
 9         epfd=epoll_create(1);//只须要监听一个描述符——标准输入
10         ev.data.fd=STDIN_FILENO;
11         ev.events=EPOLLIN|EPOLLET;//监听读状态同时设置ET模式
12         epoll_ctl(epfd,EPOLL_CTL_ADD,STDIN_FILENO,&ev);//注册epoll事件
13         for(;;)
14        {
15          nfds=epoll_wait(epfd,events,5,-1);
16          for(int i=0;i<nfds;i++)
17          {
18             if(events[i].data.fd==STDIN_FILENO)
19                cout<<"hello world!"<<endl;
20          }
21        }
22     }

(1) 当用户输入一组字符，这组字符被送入buffer，字符停留在buffer中，又由于buffer由空变为不空，因此ET返回读就绪，输出”hello world！”。spa

(2) 以后程序再次执行epoll_wait，此时虽然buffer中有内容可读，可是根据咱们上节的分析，ET并不返回就绪，致使epoll_wait阻塞。（底层缘由是ET下就绪fd的epitem只被放入rdlist一次）。code

(3) 用户再次输入一组字符，致使buffer中的内容增多，根据咱们上节的分析这将致使fd状态的改变，是对应的epitem再次加入rdlist，从而使epoll_wait返回读就绪，再次输出“hello world！”。blog

l 程序二事件

 1     #include <unistd.h>
 2     #include <iostream>
 3     #include <sys/epoll.h>
 4     using namespace std;
 5     int main(void)
 6     {
 7         int epfd,nfds;
 8         char buf[256];
 9         struct epoll_event ev,events[5];//ev用于注册事件，数组用于返回要处理的事件
10         epfd=epoll_create(1);//只须要监听一个描述符——标准输入
11         ev.data.fd=STDIN_FILENO;
12         ev.events=EPOLLIN;//使用默认LT模式
13         epoll_ctl(epfd,EPOLL_CTL_ADD,STDIN_FILENO,&ev);//注册epoll事件
14         for(;;)
15        {
16          nfds=epoll_wait(epfd,events,5,-1);
17          for(int i=0;i<nfds;i++)
18          {
19            if(events[i].data.fd==STDIN_FILENO)
20            {
21               read(STDIN_FILENO,buf,sizeof(buf));//将缓冲中的内容读出
22               cout<<"hello world!"<<endl;
23            }
24         }
25       }
26     }

程序二依然使用LT模式，可是每次epoll_wait返回读就绪的时候咱们都将buffer（缓冲）中的内容read出来，因此致使buffer再次清空，下次调用epoll_wait就会阻塞。因此可以实现咱们所想要的功能——当用户从控制台有任何输入操做时，输出”hello world！”。it

l 程序三io

 1     int main(void)
 2     {
 3         int epfd,nfds;
 4         struct epoll_event ev,events[5];//ev用于注册事件，数组用于返回要处理的事件
 5         epfd=epoll_create(1);//只须要监听一个描述符——标准输入
 6         ev.data.fd=STDIN_FILENO;
 7         ev.events=EPOLLIN|EPOLLET;//使用默认LT模式
 8         epoll_ctl(epfd,EPOLL_CTL_ADD,STDIN_FILENO,&ev);//注册epoll事件
 9         for(;;)
10        {
11          nfds=epoll_wait(epfd,events,5,-1);
12          for(int i=0;i<nfds;i++)
13          {
14            if(events[i].data.fd==STDIN_FILENO)
15             {
16               cout<<"hello world!"<<endl;
17               ev.data.fd=STDIN_FILENO;
18               ev.events=EPOLLIN|EPOLLET;//使用默认LT模式
19               epoll_ctl(epfd,EPOLL_CTL_MOD,STDIN_FILENO,&ev);//从新MOD事件（ADD无效）
20             }
21          }
22        }
23     }

程序三依然使用ET，可是每次读就绪后都主动的再次MOD IN事件，咱们发现程序再次出现死循环，也就是每次返回读就绪。这就验证了上一节讨论ET读就绪的第三种状况。可是注意，若是咱们将MOD改成ADD，将不会产生任何影响。别忘了每次ADD一个描述符都会在epitem组成的红黑树中添加一个项，咱们以前已经ADD过一次，再次ADD将阻止添加，因此在次调用ADD IN事件不会有任何影响。event

l 程序四class

 1     #include <unistd.h>
 2     #include <iostream>
 3     #include <sys/epoll.h>
 4     using namespace std;
 5     int main(void)
 6     {
 7         int epfd,nfds;
 8         struct epoll_event ev,events[5];//ev用于注册事件，数组用于返回要处理的事件
 9         epfd=epoll_create(1);//只须要监听一个描述符——标准输出
10         ev.data.fd=STDOUT_FILENO;
11         ev.events=EPOLLOUT|EPOLLET;//监听读状态同时设置ET模式
12         epoll_ctl(epfd,EPOLL_CTL_ADD,STDOUT_FILENO,&ev);//注册epoll事件
13         for(;;)
14        {
15           nfds=epoll_wait(epfd,events,5,-1);
16           for(int i=0;i<nfds;i++)
17          {
18              if(events[i].data.fd==STDOUT_FILENO)
19                  cout<<"hello world!"<<endl;
20          }
21        }
22     }

咱们发现这将是一个死循环。下面具体分析一下这个程序的执行过程：

(1) 首先初始buffer为空，buffer中有空间可写，这时不管是ET仍是LT都会将对应的epitem加入rdlist(对应第一节图中的红线)，致使epoll_wait就返回写就绪。

(2) 程序想标准输出输出”hello world！”和换行符，由于标准输出为控制台的时候缓冲是“行缓冲”,因此换行符致使buffer中的内容清空，这就对应第二节中ET模式下写就绪的第二种状况——当有旧数据被发送走时，即buffer中待写的内容变少得时候会触发fd状态的改变。因此下次epoll_wait会返回写就绪。以后重复这个过程一直循环下去。

l 程序五

相对程序四这里仅仅去掉了输出的换行操做。即：

cout<<"hello world!";

咱们看到程序成挂起状态。由于第一次epoll_wait返回写就绪后，程序向标准输出的buffer中写入“hello world!”，可是由于没有输出换行，因此buffer中的内容一直存在，下次epoll_wait的时候，虽然有写空间可是ET模式下再也不返回写就绪。回忆第一节关于ET的实现，这种状况缘由就是第一次buffer为空，致使epitem加入rdlist，返回一次就绪后移除此epitem，以后虽然buffer仍然可写，可是因为对应epitem已经再也不rdlist中，就不会对其就绪fd的events的在检测了。

l 程序六

 1     int main(void)
 2     {
 3         int epfd,nfds;
 4         struct epoll_event ev,events[5];//ev用于注册事件，数组用于返回要处理的事件
 5         epfd=epoll_create(1);//只须要监听一个描述符——标准输出
 6         ev.data.fd=STDOUT_FILENO;
 7         ev.events=EPOLLOUT;//使用默认LT模式
 8         epoll_ctl(epfd,EPOLL_CTL_ADD,STDOUT_FILENO,&ev);//注册epoll事件
 9         for(;;)
10        {
11          nfds=epoll_wait(epfd,events,5,-1);
12          for(int i=0;i<nfds;i++)
13         {
14           if(events[i].data.fd==STDOUT_FILENO)
15              cout<<"hello world!";
16         }
17        }
18     };

程序六相对程序五仅仅是修改ET模式为默认的LT模式，咱们发现程序再次死循环。这时候缘由已经很清楚了，由于当向buffer写入”hello world!”后，虽然buffer没有输出清空，可是LT模式下只有buffer有写空间就返回写就绪，因此会一直输出”hello world!”,当buffer满的时候，buffer会自动刷清输出，一样会形成epoll_wait返回写就绪。

l 程序七

 1     int main(void)
 2     {
 3         int epfd,nfds;
 4         struct epoll_event ev,events[5];//ev用于注册事件，数组用于返回要处理的事件
 5         epfd=epoll_create(1);//只须要监听一个描述符——标准输出
 6         ev.data.fd=STDOUT_FILENO;
 7         ev.events=EPOLLOUT|EPOLLET;//监听读状态同时设置ET模式
 8         epoll_ctl(epfd,EPOLL_CTL_ADD,STDOUT_FILENO,&ev);//注册epoll事件
 9         for(;;)
10        {
11          nfds=epoll_wait(epfd,events,5,-1);
12          for(int i=0;i<nfds;i++)
13         {
14            if(events[i].data.fd==STDOUT_FILENO)
15                cout<<"hello world!";
16            ev.data.fd=STDOUT_FILENO; 
17            ev.events=EPOLLOUT|EPOLLET; 
18            epoll_ctl(epfd,EPOLL_CTL_MOD,STDOUT_FILENO,&ev); //从新MOD事件（ADD无效）
19        }
20      }
21     };

程序七相对于程序五在每次向标准输出的buffer输出”hello world!”后，从新MOD OUT事件。因此至关于每次从新进行第一节中红线描述的途径返回就绪，致使程序循环输出。