高级IO—poll,epoll,reactor
高级IO—poll,epoll,reactor
文章目录
- 高级IO—poll,epoll,reactor
-
- poll函数
-
- poll函数接口
- poll服务器
- epoll
-
- epoll的系统调用
-
- epoll_create
- epoll_ctl
- epoll_wait
- epoll的工作原理
- epoll的工作方式
-
- 水平触发
- 边缘触发
- epoll服务器
- reactor
poll函数
poll函数是一个用于多路复用的系统调用，类似于select函数，用于监视一组文件描述符的状态。
poll函数接口
函数原型
#include -
fds：指向一个struct pollfd结构数组的指针，每个结构体描述一个要监视的文件描述符及其关注的事件。 -
nfds：fds数组中的结构体数量。 -
timeout：超时时间（以毫秒为单位）。设置为-1，表示阻塞式，设置为0，表示非阻塞，设置为大于0的数，例如设置为5000，表示阻塞5秒，5秒后非阻塞返回一次。
struct pollfd结构体定义如下：
struct pollfd {
int fd; // 文件描述符
short events; // 关注的事件
short revents; // 实际发生的事件-short-整数
};
- event字段用于设置关注的事件，可以使用如下宏：通过event&宏事件可以将事件添加到event中
-
revent字段用于返回实际发生的事件，也可以使用上述宏进行判断。通过revent|宏事件可以得知revent中是否包含了该就绪事件
-
poll函数的返回值是就绪文件描述符的数量，返回值大于0表示已经有文件描述符就绪，返回值等于0表示没有文件描述符就绪，返回值小于0表示出错，可以使用perror输出错误信息。
总结一下：
- 在poll函数的pollfd结构体中，有event参数保存用户需要OS关心的事件，有revent参数保存OS告诉用户就绪的事件，即做到了输入输出分离，不需要像select函数借助第三方数组对sock进行管理。
- poll函数等待文件描述符理论上没有上限。由于参数fds是一个动态数组，并不是一个确定的结构。不同于位图，动态数组可以动态扩容。且动态数组的大小取决于用户传入的nfds。
poll服务器
现对select服务器套用poll函数，改造成poll服务器。只需要对实现业务hpp改造即可
pollserver.hpp
#pragma once
#include
int n=poll(_rfds,fdnum,timeout);
// cout<<"poll finished"<
switch(n)
{
case 0:
logMessage(NORMAL,"timeout...");
break;
case -1:
logMessage(WARNING,"poll error");
break;
default:
logMessage(NORMAL,"poll success");
Handlerop();
break;
}
}
}
~PollServer()
{
if (_listensock < 0) // 为什么是小于0？
close(_listensock);
if(_rfds!=nullptr)
delete[]_rfds;
}
private:
int _port;
int _listensock;
struct pollfd* _rfds;//指向poll结构体的指针
func_t _func;
};
}
总结一下：
- poll函数通过输入输出分离，避免了借用第三方数组来记录sock和事件。
- poll解决了select具有管理文件描述符数量上限的问题。
- poll依旧存在遍历问题。由于检查就绪事件依旧是需要遍历整个数组，即时间复杂度为O(N)。
epoll模型可以解决遍历问题，使得检查就绪事件的时间复杂度优化到O(1)。
epoll
epoll的系统调用
epoll_create
epoll_create用于创建一个epoll模型
函数原型
int epoll_create(int size);
size指定了 epoll 实例能够同时监视的文件描述符的数量上限。- 返回值为一个非负整数的文件描述符epollfd，表示创建的epoll模型对象。创建失败，返回值为-1。可以传递epollfd给epoll_ctl函数像epoll模型中添加、修改、删除需要监视的文件描述符以及事件。
- 注意一下：使用epoll模型后，需要关闭epollfd。
epoll_ctl
epoll_ctl 函数用于向 epoll 实例中添加、修改或删除要监视的文件描述符，并设置关注的事件。
函数原型
#include epfd：epoll 模型的文件描述符，由epoll_create函数返回。op：操作类型，可以是这些值：
EPOLL_CTL_ADD：将文件描述符fd添加到 epoll 模型中。
EPOLL_CTL_MOD：修改已经添加到 epoll模型中的文件描述符fd的关注事件。
EPOLL_CTL_DEL：从 epoll模型中删除文件描述符fd。fd：要添加、修改或删除的文件描述符。event：指向struct epoll_event结构体的指针，用于设置关注的事件。
struct epoll_event结构体定义如下：
struct epoll_event {
_uint32_t events; // 关注的事件
epoll_data_t data; // 用户数据
};
- events字段用于设置关注的事件。可以使用以下宏设置：
EPOLLIN：可读事件。EPOLLOUT：可写事件。EPOLLPRI：紧急事件。EPOLLERR：错误事件。EPOLLHUP：挂起事件。EPOLLET：边缘触发模式。EPOLLONESHOT：一次性事件。
epoll_data_t结构定义如下：
typedef union epoll_data
{
void *ptr;
int fd;
uint32_t u32;
uint64_t u64;
} epoll_data_t;
-
fd是用户传递需要监管的文件描述符。
-
调用成功返回0，失败返回-1。
epoll_wait
epoll_wait函数用于收集epoll模型中已经就绪的事件，并将就绪事件的个数返回
函数原型
#include epfd：epoll 实例的文件描述符，由epoll_create函数返回。events：指向struct epoll_event结构体数组的指针，用于存储就绪的事件。maxevents：events数组的大小，表示最多可以存储多少个事件。timeout：等待事件的超时时间，单位为毫秒。设置为-1，表示阻塞式，设置为0，表示非阻塞，设置为大于0的数，例如设置为5000，表示阻塞5秒，5秒后非阻塞返回一次。- 函数的返回值表示就绪的事件数量，返回值大于0表示已经有事件就绪，返回值等于0表示超时返回，无事发生。返回值小于0表示调用出错。
epoll的工作原理
数据本身只能按照输入设备—内存—CPU—内存—输出设备的方向流动。
-
网络数据到达主机时，是先到达网卡，即网课外设。CPU有很多针脚，外设虽然不会与CPU有直接的数据流通，但外设可以将信号直接发送到CPU的阵脚上（硬件中断）。外设通过中断设备，将电子信号发送到CPU上。CPU会将该信号转发到中断向量表，根据信号的值找到对应的表中位置（下标），该表是一张函数指针数组，根据指针能够调用驱动方法，驱动方法将数据拷贝到内存上，即数据从硬件传输到了OS中。
-
在OS中，会以红黑树的方式管理sock和events。每个节点上都有sock和event，当然还有left指针和right指针。红黑树的优点是查找效率高。当用户告诉内核那些事件需要被关心时，OS会将需要关心的事件、sock放到该红黑树当中。当事件就绪，OS会将红黑树上的节点添加到就绪队列中，该就绪队列中的成员表示内核需要告诉用户，那些事件已经就绪，等待上层将该事件资源取走。实际上，一个节点即能存在于红黑树中，也能存在于就绪队列中。
总结一下：
网络数据到来后，外设通过信号中断将数据拷贝到内存上。细致的说，是底层收到数据后，贯穿网络协议栈向上交付数据，可以把红黑树的节点看作成文件描述符sock，根据sock找到对应的文件结构体struct file，该结构体内有指针指向接收缓存区，然后将数据填充到该文件接收缓冲区中。随后调用struct file中的回调方法（void* private data指针指向一个回调函数）-回调机制，该回调方法会将红黑树中的节点添加到就绪队列当中，表示该事件已经就绪，通知用户来取走数据。
红黑树、就绪队列、epoll管理的文件struct file以及部分网络协议栈一整套可以认作成一个epoll模型。进程可以通过文件描述符表找到epoll_create的返回值epollfd，epollfd会指向自己的struct file，在struct file中有关联指针能够找到对应的epoll模型。
重新看待epoll的相关接口。操作系统需要提供接口该上层使用。
#include epoll_create创建epoll模型，并返回一个epollfd供上层使用。
#include epoll_ctl根据提供的epollfd找到对应的epoll模型，根据提供的fd和event增删改红黑树中的节点。
int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
epoll_wait根据epollfd找到对应的epoll模型，根据提供的events、maxevents、timeout管理就绪队列中的节点。而epoll_wait检测就绪事件，只需要检测已经就绪的事件，不需要遍历检测整个需要管理的事件表，只需要将就绪的事件（资源）从内核层拷贝到用户层。因此遍历的事件复杂度为O(1)。
其次，epoll_wait会按照传入的顺序，依次放回到就绪事件数组中。根据队列先进先出的特性，若就绪队列中有很多数据节点，一次性拿不完，可以下一次调用epoll_wait再拿。
而伴随epoll模型的创建的辅助数组，就是该管理需要关心事件的红黑树。红黑树节点是以kv形式存在，由于sock是不会重复的，因此sock作为key。
epoll相比于select、poll，将大部分管理任务分配给操作系统负责，也因此epoll的接口相比较简单。
epoll的工作方式
前面都有提到select、poll、epoll在事件就绪的时候通知上层将事件处理。事件就绪可以认为底层的IO条件满足，可以进行某种IO行为，epoll就会通知上层进行这种IO行为将底层的数据提取走。
epoll有2种通知策略，即水平触发(LT)和边缘触发(ET)
水平触发
-
水平触发为Level Triggered，简称LT。
epoll默认状态下是LT工作策略。 -
水平触发关心的是缓冲区的状态，当缓冲区可读的时候，就会一直发出通知，也就是当缓冲区中只要有数据就会发出通知，知道上层将缓冲区的所有数据读完。可以认为你在做老师布置的作业，写了但没写完的情况下，老师就会一直通知你写作业，直到作业完全写完。
-
LT的优势在于：可以在读取数据的时候只读取一部分，在第二次调用
epoll_wait时立刻返回并通知上层将底层数据读走。 -
支持阻塞读写和阻塞读写。‘
边缘触发
- 边缘触发为Edge Triggered。简称ET。
- 边缘触发关心的是缓冲区状态的变化，当缓冲区状态发生变化的时候才会发出通知，比如缓冲区中来了新的数据。底层有数据，ET模式下epoll只会通知上层一次，后续缓冲区来了新的数据，epoll才会再次通知。
- ET优势在于：ET是一次性通知的方式，倒逼上层尽量做到一次性将数据读完。其次是尽可能一次性读取多的数据，从而使得接收缓冲区可容纳下一次数据的空间尽可能的大，那么接收方的接收能力自然就强，能够告诉发送数据方：接收方的滑动窗口较大，让对方更新出更大的滑动窗口，提高数据发送的效率。
- ET模式下，文件描述符要求是非阻塞的。由于底层的事件到达增多，OS才会通知上层将数据取走，因此用户提取数据时，尽量调用一次
read,recv就把数据取完，而为了避免一次性调用函数没有读完，就需要循环调用读取函数，当调用读取函数直到读取不到数据才算作读完数据。若fd是阻塞的，那么读取函数进行最后一次读取时读取不到数据，就会阻塞，因此fd需要是非阻塞的，读取不到数据直接返回。
LT模式下，fd可以是阻塞的也可以是非阻塞的。LT可以模拟ET工作方式。
epoll服务器
epollserver.cc
#include
// }
string resp(const string& s)
{
return s;
}
int main(int argc,char* argv[])
{
// if(argc!=2)
// {
// Usage(argv[0]);
// exit(USAGE_ERR);
// }
unique_ptr<EpollServer> epolsv(new EpollServer(resp));
epolsv->initServer();
epolsv->start();
return 0;
}
log.hpp
#pragma once
#include Sock.hpp
#pragma once
#include- 默认的LT模式下的epollserver
epollserver.hpp
#pragma once
#include 
客户端连接上但不处理就会一直通知。
- ET模式下的epollserver服务器
epollserver.hpp
#pragma once
#include - 需要将文件描述符都设置成EPOLLET模式，在处理事件函数内，若sock是EPOLLET模式，就调用setNonBlock将该sock设置成非阻塞。
Sock.hpp
#pragma once
#include- Sock类内新增了setNonBlock函数，用于将传导过来的sock设置成非阻塞。
可以看到底层事件就绪时，ET模式下的epollserver只通知了上层一次。
reactor
通过Reactor对底层事件的关心，底层有就绪事件，就通知上层的Connection类对象调用相关函数处理就绪事件。
Connection类
using func_t = function<void(Connection *)>;
class Connection
{
public:
Connection(int sock, Tcpserver *tcps) : _consock(sock), _tcps(tcps)
{
}
~Connection() {}
void Register(func_t r, func_t w, func_t e) // 注册方法表，将方法传递进来
{
_reader = r;
_writer = w;
_excepter = e;
}
void Close()
{
close(_consock);
}
public:
string _inbuffer; // 输入缓冲区
string _outbuffer; // 输出缓冲区
func_t _reader; // 读操作
func_t _writer; // 写操作
func_t _excepter; // 处理异常操作
int _consock;
Tcpserver *_tcps; // 指向Tcpserver对象的指针
};
- 每一个文件描述符需要配备独自的堆上的接收缓冲区和输出缓冲区。先描述再组织，因此创建了结构体
Connection，结构体内含文件描述符，及其配备的输出缓冲区，接收缓冲区，该缓冲区类型为string，当前该缓冲区只能处理字符串。三个回调函数。三个回调方法通过外部传参。回调方法分别是读事件方法、写事件方法、异常事件方法。 - 由于Connection对象内的回调函数是Tcpserver对象赋予的，因此需要先了解一下三个回调函数。
Accepter：负责获取连接，并将新连接添加到Connection对象内。
void Accepter(Connection *con) // 针对listenfd，将获取到的连接从底层拿到应用层
{
for (;;)
{
logMessage(DEBUG, "enter Accepter");
string clientip;
uint16_t clientport;
int err = 0;
int sock = _sock.Accpet(&clientip, &clientport, &err); // 获取成功，返回新的文件描述符用于通信，客户端的ip和port通过参数返回
if (sock > 0)
{
// 连接拿上来了，将fd添加到con对象中
AddConnection(sock, EPOLLIN | EPOLLET,
bind(&Tcpserver::Recver, this, placeholders::_1),
bind(&Tcpserver::Sender, this, placeholders::_1),
bind(&Tcpserver::Excepter, this, placeholders::_1));
logMessage(DEBUG, "get new link,[%s:%d]", clientip.c_str(), clientport);
}
else
{
if (err == EAGAIN || err == EWOULDBLOCK)
break; // 读完了
else if (err == EINTR)
continue; // 因为中断，继续读
else
break; // 错误
}
}
}
Recver：负责读取底层的数据
void Recver(Connection *con) // 读事件
{
char buffer[1024];
while (true)
{
ssize_t i = recv(con->_consock, buffer, sizeof(buffer) - 1, 0);
if (i > 0)
{
buffer[i] = 0;
con->_inbuffer += buffer;//每次读到的数据放到配套的缓冲区内
logMessage(DEBUG, "recv str: %s", con->_inbuffer.c_str());
_func(con);
}
else if (i == 0) // 断开连接，异常处理
{
if (con->_excepter)
{
con->_excepter(con);
return;
}
}
else
{
if (errno == EAGAIN || errno == EWOULDBLOCK)
{
break; // 读完了
}
else if (errno == EINTR) // 因信号中断，继续读
{
continue;
}
else
{
if (con->_excepter)
{
con->_excepter(con);
return;
}
}
}
}
}
- 将每次读取到的数据填充到配备的接收缓冲区，读到完整报文后，调用
_func函数处理数据。
Sender：将sock配备的输出缓冲区内的数据发回给客户端。
void Sender(Connection *con) // 写事件
{
while (true)
{
ssize_t i = send(con->_consock, con->_outbuffer.c_str(), sizeof(con->_outbuffer), 0);
if (i > 0)
{
if (con->_outbuffer.empty()) // 内容当前send函数一次性发完了
{
logMessage(DEBUG, "sender finish");
con->_tcps->EnableReadWrite(con, true, false); // 发完了，把写通道关闭
// sleep(2);
break;
}
else
{
logMessage(DEBUG, "sender not finish");
con->_outbuffer.erase(0, i); // 如果一次性没发完，那么就将发完的部分删减掉，剩余的下次再发
}
}
else
{
if (errno == EAGAIN || errno == EWOULDBLOCK) // 上次发完了，这次再发就会err为这两个字段
{
break;
}
else if (errno == EINTR)
{
continue; // 因信号中断了，继续发送
}
else
{
logMessage(DEBUG, "excepter");
if (con->_excepter) // 异常了，执行异常事件
{
con->_excepter(con);
return;
}
}
}
}
Tcpserver.hpp
#pragma once
#include
{ // 拿到就绪事件的fd和event
// sleep(2);
// logMessage(DEBUG, "enter Loop for");
//提取sock和event
int sock = _revs[i].data.fd;
uint32_t event = _revs[i].events;
//处理异常事件--如果是异常事件，那么会进入读事件和写事件，但是读事件是不就绪的即读出错，就会走到处理异常的代码区。
//同样的写事件也会发送写出错，走到处理异常的代码区
if (event & EPOLLERR)
// logMessage(DEBUG, "event & EPOLLERR");
event |= (EPOLLIN | EPOLLOUT);
if (event & EPOLLHUP)
// logMessage(DEBUG, "event & EPOLLHUP");
event |= (EPOLLIN | EPOLLOUT); // 如果事件异常了，就将该事件设置为读写事件
// listenfd事件就绪
if ((event & EPOLLIN) && (Isexist(sock)) && (_Connections[sock]->_reader))
{
logMessage(DEBUG, "con->_reader");
_Connections[sock]->_reader(_Connections[sock]);
}
if ((event & EPOLLOUT) && (Isexist(sock)) && (_Connections[sock]->_writer))
{
logMessage(DEBUG, "con->_writer");
_Connections[sock]->_writer(_Connections[sock]);
}
}
// logMessage(DEBUG, "quit Loop");
}
public:
Tcpserver(func_t fun, int port = defaultport) : _port(port), _func(fun)
{
}
void inittcpserver()
{
logMessage(DEBUG, "enter inittcpserver\n");
// 1.创建文件描述符
_sock.Socket(); // 创建文件描述符--用于建立连接
_sock.Bind(_port); // 绑定端口号和ip
_sock.Listen(); // 将文件描述符设置为监视状态
// 2.创建epoll模型
_epoller.Create();
//3.将listenfd添加到con对象，即添加到epoll中，并且注册配备的缓冲区和回调函数
AddConnection(_sock.Fd(), EPOLLIN | EPOLLET,\
bind(&Tcpserver::Accepter, this, placeholders::_1), nullptr, nullptr); // 对于listenfd来说，只关心读取事件
logMessage(DEBUG, "quit inittcpserver\n");
_revs = new struct epoll_event[Gnum]; // 创建一个事件集合，供后续存放已经就绪的事件使用
_num = Gnum;
}
void EnableReadWrite(Connection *con, bool readable, bool writable)
{//判断
uint32_t event = (readable ? EPOLLIN : 0) | (writable ? EPOLLOUT : 0) | EPOLLET;
_epoller.Control(con->_consock, event, EPOLL_CTL_MOD);
}
void Distribute()//事件派发s
{
logMessage(DEBUG, "enter Distribute");
while (true)
{
Loop(-1);
}
logMessage(DEBUG, "quit Distribute");
}
~Tcpserver()
{
_epoller.Close();
if (_revs != nullptr)
delete[] _revs;
}
private:
uint16_t _port;
Sock _sock;
Epoller _epoller;
unordered_map<int, Connection *> _Connections; // 建立sock和connection对象的映射表
struct epoll_event *_revs; // 用来存储返回的事件
func_t _func;
int _num; // 可监管的事件总数
};
}
- 该代码中的bind用法是bind类内成员函数。用法是第一个参数需要传递类内成员函数对象的指针，第二个参数需要传递类对象的指针，后面才是传递类成员函数需要的参数。对一个成员函数对象使用bind后形成一个新的函数对象。例如调用AddConnection函数时，第三四五参数是仿函数对象，通过bind将传入的类内成员函数对象转换为仿函数对象。以传递Recver函数为例，在bind表达式内，第一个参数传递Recver函数对象指针，第二个参数传递Tcpserver类指针，第三个参数传递的是需要传递给Recver函数对象的参数，即con指针。通过bind，将Tcpserver内的Recver成员函数转换为Connection类内的_reader成员函数。
-
建立sock和Connection对象的映射关系，以sock作为key值，Connection对象的指针作为value值，建立unordered_map数据结构进行组织管理，Connection对象内是针对key值的sock配备的缓冲区，处理函数。
-
在epoll中读取到数据，处理完后不能立刻发送回给客户端。因为发送缓冲区是否具有空间是未知的。服务器启动后，发送条件是就绪的，是可以直接发送，但会存在一次性发送完的情况，可以下一次调用sender的时候再发送，这就要求每一个sock需要配备自己的发送缓冲区。并且将发送事件注册到epoll中，让epoll管理。由于服务器的需求以接收事件居多，发送事件相比需求不大，因此对于epoll来说接收事件是常规设置，发送事件是按需设置。
main.cc
#include protocol.hpp
#pragma once
#includelog.hpp
#pragma once
#include Sock.hpp
#pragma once
#includeuntil.hpp
#pragma once
#includeEpoller.hpp
#pragma once
#include 由于该reactor处理的是类似于接收“1+1”的完整报文的数据，返回客户端所得数的业务，因此客户端也需要能够具备发送完整报文的能力。
calclient.cc
#includecalclient.hpp
#pragma once
#include 
reactor保证了事件就绪，还负责了IO，并且还完成了业务处理。负责了IO过程+业务处理，该过程称为半同步。实际上可以将业务放到其他处理逻辑上，只负责IO过程，这称为半异步。