poll
poll函数原型
函数原型
#include <poll.h>
int poll(struct pollfd *fds, nfds_t nfds, int timeout);
参数：
fds:结构体指针，可以把结构体数组的首地址传递进来；fds是输入输出参数，一旦这些事件中的一个或多个发生了，就会返回回来，所以可以根据poll返回回来的事件来进行处理；
nfds:监听的fd的个数；
timeout:超时时间；
struct pollfd {
int fd; /* file descriptor */文件描述符
short events; /* requested events */感兴趣的事件
short revents; /* returned events */实际发生的事件，返回的事件
};
poll使用流程
（P3）poll：poll函数原型
（1）如果应用层发过来的数据包，刚好分包了，即：一个数据包，两次read（粘包问题），第一次read时并不是一个完整的客户端请求，该怎么办呢？
对于每一个connfd分配一个应用层缓冲区，我们应该将读到的数据保存在connfd的应用层接收缓冲区，将每次读到的数据追加到应用层缓冲区的末尾。
如何解析协议？让解析协议去应用层缓冲区去读取数据，判断它是否为一条完整的消息，然后对消息进行处理。
（2）假设应答的数据量比较大，假如10000字节，write的时候实际上只发送了1000字节，因为内核发送缓冲区有可能满了，该缓冲区满了，write系统调用不会阻塞，因为connfd是非阻塞的fd（connfd = accept4(listenfd, (struct sockaddr*)&peeraddr, &peerlen, SOCK_NONBLOCK | SOCK_CLOEXEC);），如果设置成阻塞模式，会把线程阻塞住了，其他的fd产生了事件就没办法处理了，会降低并发服务器效率，所以要用非阻塞的fd！！！
当发送缓冲区满了，write不能把所有的数据都发送出去，我们也应该有一个应用层的发送缓冲区。
什么时候产生可写事件，即POLLOUT事件？
POLLOUT事件的触发条件：connfd内核中的发送缓冲区不满时(可以容纳事件了)，就把应用层的缓冲区拷贝到内核中的缓冲区当中。
不能一接收到connfd事件的时候就关注POLLOUT事件，如果一开始就关注，刚开始的时候，发送缓冲区不是满的，但是又没有发送数据，它会一直触发POLLOUT事件，则会出现忙等待busy-loop。所以，应该在内核缓冲区已经满了，才关注它的POLLOUT事件，随着内核缓冲区的数据发送出去，被对等方接收走，发送缓冲区的数据就会被移除，就会腾出空间接受更多的数据，此时POLLOUT事件就发生了，再poll一遍检测到事件，在处理已连接套接字事件的时候，遍历已连接套接字集，就有可能遍历到connfd POLLOUT事件的到来，此时取出应用层缓冲区的数据进行发送，如果这次还没发送完，那么POLLOUT事件就不能取消关注
epoll
epoll函数原型
#include <sys/epoll.h>
int epoll_create(int size);
int epoll_create1(int flags);
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
联合体，随便用，联合体最大是uint64_t ，所以是8个字节
typedef union epoll_data {
void *ptr;
int fd;4字节
uint32_t u32;
uint64_t u64;
} epoll_data_t;
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */对哪个fd进行关注，填在这里
};
-
两种触发模式
（1）Level-Triggered，与poll类似
（2）Edge-Triggered，边沿触发 -
如果采用Level-Triggered，那什么时候关注EPOLLOUT事件?会不会造成busy-loop?
看poll（（P4）poll：poll使用的基本流程 ，EMFILE处理 ，cmake），epoll的LT与poll一样
epoll LT
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <signal.h>
#include <fcntl.h>
#include <sys/wait.h>
#include <sys/epoll.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <vector>
#include <algorithm>
#include <iostream>
typedef std::vector<struct epoll_event> EventList;
#define ERR_EXIT(m) \
do \
{ \
perror(m); \
exit(EXIT_FAILURE); \
} while(0)
int main(void)
{
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
int idlefd = open("/dev/null", O_RDONLY | O_CLOEXEC);
int listenfd;
//if ((listenfd = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
if ((listenfd = socket(PF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, IPPROTO_TCP)) < 0)
ERR_EXIT("socket");
struct sockaddr_in servaddr;
memset(&servaddr, 0, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(5188);
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
int on = 1;
if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
ERR_EXIT("setsockopt");
if (bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
ERR_EXIT("bind");
if (listen(listenfd, SOMAXCONN) < 0)
ERR_EXIT("listen");
std::vector<int> clients;
int epollfd; //epoll_create(能够处理的fd的个数，这个数随便填，系统资源能管多少fd，他就有多少，就能处理多大的并发)
epollfd = epoll_create1(EPOLL_CLOEXEC);//man epoll_create,epoll_create1=epoll_create+fcntl+EPOLL_CLOEXEC
struct epoll_event event;
event.data.fd = listenfd;
event.events = EPOLLIN/* |默认是LT模式。 EPOLLET*/;
epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event);//将listenfd添加到epollfd进行关注，以及所关注的事件添加到epollfd进行管理
//初始状态里面要有关注的事件
EventList events(16);//初始化一个事件列表
struct sockaddr_in peeraddr;
socklen_t peerlen;
int connfd;
int nready;
while (1)
{
//&*events.begin()第一个元素的地址
//static_cast<int>(events.size())：enents大小
//-1：表示等待
//返回的事件都放在&*events.begin(),这仅仅是个输出参数，不需要传递关注的事件。关注的事件由epoll_ctl来传递了，由epollfd来管理，
//而poll是一个输入输出参数，要把里面的数据拷贝到内核，就多了数据拷贝
/*
这块内容在poll中是应用层的数组&*events.begin()管理的，现在由内核取管理了，内核开辟了一个数据结构，将关注的事件放到这个数据结构中
epollfd = epoll_create1(EPOLL_CLOEXEC);
。。。
epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event)
所以，epoll的&*events.begin()只是一个输出参数，意味着：每次等待的时候，不需要每次把我们要关注的事件拷贝到内核，不需要每次从用户空间将数据拷贝到
内核空间
*/
//nready：返回的事件个数
nready = epoll_wait(epollfd, &*events.begin(), static_cast<int>(events.size()), -1);//相当于poll
if (nready == -1)
{
if (errno == EINTR)
continue;
ERR_EXIT("epoll_wait");
}
if (nready == 0) // nothing happended
continue;
//返回的事件个数=16，说明空间不够了。就成倍扩大
if ((size_t)nready == events.size())
events.resize(events.size()*2);
for (int i = 0; i < nready; ++i)
{
//这里的events都是活跃的fd
if (events[i].data.fd == listenfd)
{
peerlen = sizeof(peeraddr);
connfd = ::accept4(listenfd, (struct sockaddr*)&peeraddr,
&peerlen, SOCK_NONBLOCK | SOCK_CLOEXEC);
if (connfd == -1)
{
if (errno == EMFILE)
{
close(idlefd);
idlefd = accept(listenfd, NULL, NULL);
close(idlefd);
idlefd = open("/dev/null", O_RDONLY | O_CLOEXEC);
continue;
}
else
ERR_EXIT("accept4");
}
std::cout<<"ip="<<inet_ntoa(peeraddr.sin_addr)<<
" port="<<ntohs(peeraddr.sin_port)<<std::endl;
clients.push_back(connfd);
event.data.fd = connfd;
event.events = EPOLLIN/* | EPOLLET*/;
epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event);//将connfd加入关注EPOLL_CTL_ADD
}
//处理完listenfd，就处理connfd
else if (events[i].events & EPOLLIN)
{
connfd = events[i].data.fd;
if (connfd < 0)
continue;
char buf[1024] = {0};
int ret = read(connfd, buf, 1024);
if (ret == -1)
ERR_EXIT("read");
if (ret == 0)//对方关闭
{
std::cout<<"client close"<<std::endl;
close(connfd);
event = events[i];
epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);//剔除connfd，下次不关注
clients.erase(std::remove(clients.begin(), clients.end(), connfd), clients.end());
continue;
}
std::cout<<buf;
write(connfd, buf, strlen(buf));
}
}
}
return 0;
}
epoll ET
- epoll ET
- epoll ET模式的EMFILE问题
7239
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
