IO多路复用之epoll(二)

前一篇介绍了epoll的LT模式,LT模式注意epollout事件在数据全部写成功后需要取消关注,

或者更改为EPOLLIN。

而这次epoll的ET模式,要注意的是在读和写的过程中要在循环中写完或者读完所有数据,

确保不要丢掉一些数据。

因为epoll ET模式只在两种边缘更改的时候触发,对于读事件只在内核缓冲区由空变为

非空通知一次用户,对于写事件,内核缓冲区只在由满变为非满的情况通知用户一次。

下面是代码

int main()
{

int eventsize = 20;
struct epoll_event * epoll_eventsList = (struct epoll_event *)malloc(sizeof(struct epoll_event)

*eventsize);

//打开一个空的描述符
int idlefd = open("/dev/null",O_RDONLY|O_CLOEXEC);
cout << "idlefd" <<idlefd <<endl;
//生成listen描述符

int listenfd = socket(PF_INET, SOCK_CLOEXEC | SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);
if(listenfd < 0)
{
ERR_EXIT("socketfd");
}

//初始化地址信息
struct sockaddr_in servaddr;
memset(&servaddr,0 ,sizeof(struct sockaddr_in));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(6667);
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)))
ERR_EXIT("bindError");

if (listen(listenfd, SOMAXCONN) < 0)
ERR_EXIT("listen");

//记录客户端连接对应的socket
std::vector<int> clients;
//创建epollfd, 用于管理epoll事件表
int epollfd;
epollfd = epoll_create1(EPOLL_CLOEXEC);

struct epoll_event event;
event.data.fd = listenfd;
event.events = EPOLLIN|EPOLLET;
//将listenfd加入到epollfd管理的表里
epoll_ctl(epollfd, EPOLL_CTL_ADD, listenfd, &event);

//用于接收新连接的客户端地址
struct sockaddr_in peeraddr;
socklen_t peerlen;
int connfd;
//为了简单起见写了个很大的数组,根据文件描述符存储内容
//其实很多项目代码采epoll.data.ptr回调具体的读写

vector<string> recievebuf;

for(int i = 0 ; i < 22222; i++)
{
recievebuf.push_back("");
}

while(1)
{
int nready = epoll_wait(epollfd, epoll_eventsList, eventsize, -1);
if (nready == -1)
{
if (errno == EINTR)
continue;

ERR_EXIT("epoll_wait");
}
if (nready == 0)
continue;

//大小不够重新开辟

if ((size_t)nready == eventsize)
{
if(eventsize * 2 >= 22222)
{
ERR_EXIT("too many fds");
}

struct epoll_event * epoll_eventsList2 = (struct epoll_event *)malloc(sizeof(struct epoll_event) *
eventsize *2);
if(epoll_eventsList2)
{
memcpy(epoll_eventsList2,epoll_eventsList,sizeof(struct epoll_event) * eventsize);
eventsize = eventsize * 2;
free(epoll_eventsList);
epoll_eventsList = epoll_eventsList2;

}

}

for (int i = 0; i < nready; ++i)
{
//判断wait返回的events数组状态是否正常
if ((epoll_eventsList[i].events & EPOLLERR) ||
(epoll_eventsList[i].events & EPOLLHUP))
{
fprintf (stderr, "epoll error\n");
close (epoll_eventsList[i].data.fd);
continue;

}

if (epoll_eventsList[i].data.fd == listenfd)
{
peerlen = sizeof(peeraddr);
//ET模式accept放在while循环里

do
{
connfd = ::accept4(listenfd, (struct sockaddr*)&peeraddr,
&peerlen, SOCK_NONBLOCK | SOCK_CLOEXEC);

if(connfd <= 0)
break;

std::cout<<"ip="<<inet_ntoa(peeraddr.sin_addr)<<
" port="<<ntohs(peeraddr.sin_port)<<std::endl;
clients.push_back(connfd);

//将connd加入epoll表里,关注读事件

event.data.fd = connfd;
event.events = EPOLLIN |EPOLLET;
epoll_ctl(epollfd, EPOLL_CTL_ADD, connfd, &event);
cout << "loop" <<endl;
cout << "loop" << connfd << endl;
}while(1);
//accept失败,判断是否接收全所有的fd
cout << connfd << endl;
if (connfd == -1){
if (errno != EAGAIN && errno != ECONNABORTED
&& errno != EPROTO && errno != EINTR)
{
cout << "error" <<endl;
ERR_EXIT("accept");
}

}

//所有请求都处理完成
cout << "continue"<<endl;
continue;

}//endif
else if(epoll_eventsList[i].events & EPOLLIN)
{
connfd = epoll_eventsList[i].data.fd;
if(connfd > 22222)
{
close(connfd);
event = epoll_eventsList[i];
epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);
clients.erase(std::remove(clients.begin(), clients.end(), connfd), clients.end());
continue;

}

char buf[1024] = {0};
if(connfd < 0)
continue;
int ret = 0;
int total = 0;
std::string strtemp;
while(1)
{
cout << "begin read" <<endl;
ret = read(connfd, buf, 1024);
if(ret <= 0)
{
break;
}

strtemp += string(buf);
total += ret;
memset(buf, 0, 1024);

if(ret < 1024)
{
break;
}

}//endwhile(1)

cout << "end read" <<endl;
recievebuf[connfd] = strtemp.c_str();
cout << "buff data :" << recievebuf[connfd]<<endl;
if(ret == -1)
{
if((errno == EAGAIN) ||
(errno == EWOULDBLOCK))
{
//由于内核缓冲区空了,下次有数据到来是会触发epollin
continue;
}

ERR_EXIT("read");

}//endif ret == -1

//连接断开
if(ret == 0)
{
std::cout<<"client close"<<std::endl;
close(connfd);
event = epoll_eventsList[i];
epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);
clients.erase(std::remove(clients.begin(), clients.end(), connfd), clients.end());
continue;

}

cout << "turn to write" << endl;
//更改为写模式

event.data.fd = connfd;
event.events = EPOLLOUT | EPOLLET;

epoll_ctl(epollfd, EPOLL_CTL_MOD, connfd, &event);
cout << "epoll mod change success" << endl;

}//end elif

else //写事件
{

if(epoll_eventsList[i].events & EPOLLOUT)
{
cout << "begin write" <<endl;
connfd = epoll_eventsList[i].data.fd;
int count = 0;
int totalsend = 0;
char buf[1024];
strcpy(buf, recievebuf[connfd].c_str());

cout << "write buff" <<buf<<endl;
while(1)
{
int totalcount = strlen(buf);
int pos = 0;
count = write(epoll_eventsList[i].data.fd, buf + pos, totalcount);
cout << "write count:" << count;
if(count < 0)
{
break;
}

if(count < totalcount)
{
totalcount = totalcount - count;
pos += count;

}
else
{
break;

}

}//end while

if(count == -1)
{
if((errno == EAGAIN) ||
(errno == EWOULDBLOCK))
{
//由于内核缓冲区满了
//于内核缓冲区满了
continue;
}

ERR_EXIT("write");
}

if(count == 0)
{
std::cout<<"client close"<<std::endl;
close(connfd);
event = epoll_eventsList[i];
epoll_ctl(epollfd, EPOLL_CTL_DEL, connfd, &event);
clients.erase(std::remove(clients.begin(), clients.end(), connfd),
clients.end());
continue;

}

event.data.fd = connfd;
event.events = EPOLLIN|EPOLLET;
epoll_ctl(epollfd, EPOLL_CTL_MOD, connfd, &event);

}

}//end eles 写事件

}

}

}

源代码下载地址:http://download.csdn.net/detail/secondtonone1/9486222

时间: 2024-09-30 21:09:15

IO多路复用之epoll(二)的相关文章

IO多路复用之epoll

1.基本知识 epoll是在2.6内核中提出的,是之前的select和poll的增强版本.相对于select和poll来说,epoll更加灵活,没有描述符限制.epoll使用一个文件描述符管理多个描述符,将用户关系的文件描述符的事件存放到内核的一个事件表中,这样在用户空间和内核空间的copy只需一次. 2.epoll接口 epoll操作过程需要三个接口,分别如下: #include <sys/epoll.h> int epoll_create(int size); int epoll_ctl(

IO多路复用之epoll总结

1.基本知识 epoll是在2.6内核中提出的(mac没有),是之前的select和poll的增强版本.相对于select和poll来说,epoll更加灵活,没有描述符限制.epoll使用一个文件描述符管理多个描述符,将用户关系的文件描述符的事件存放到内核的一个事件表中,这样在用户空间和内核空间的copy 只需一次. ==>内核事件表?? 2.epoll接口 epoll操作过程需要三个接口,分别如下:llinux 系统 $man  epoll 查看是否支持epoll #include <sys

Linux IO多路复用之epoll网络编程及源码(转)

原文: 前言 本章节是用基本的Linux基本函数加上epoll调用编写一个完整的服务器和客户端例子,可在Linux上运行,客户端和服务端的功能如下: 客户端从标准输入读入一行,发送到服务端 服务端从网络读取一行,然后输出到客户端 客户端收到服务端的响应,输出这一行到标准输出 服务端代码 代码如下: #include <unistd.h> #include <sys/types.h> /* basic system data types */ #include <sys/soc

IO多路复用(二) -- select、poll、epoll实现TCP反射程序

接着上文IO多路复用(一)-- Select.Poll.Epoll,接下来将演示一个TCP回射程序,源代码来自于该博文https://www.cnblogs.com/Anker/p/3258674.html 博主的几篇相关的文章,在这里将其进行了整合,突出select.poll和epoll不同方法之间的比较,但是代码的结构相同,为了突出方法之间的差别,可能有的代码改动的并不合理,实际中使用并非这么写. 程序逻辑 该程序的主要逻辑如下: 服务器: 1. 开启服务器套接字 2. 将服务器套接字加入要

用C写一个web服务器(二) I/O多路复用之epoll

.container { margin-right: auto; margin-left: auto; padding-left: 15px; padding-right: 15px } .container::before,.container::after { content: " "; display: table } .container::after { clear: both } .container::before,.container::after { content:

IO多路复用select、poll、epoll的区别

(1)select==>时间复杂度O(n) 它仅仅知道了,有I/O事件发生了,却并不知道是哪那几个流(可能有一个,多个,甚至全部),我们只能无差别轮询所有流,找出能读出数据,或者写入数据的流,对他们进行操作.所以select具有O(n)的无差别轮询复杂度,同时处理的流越多,无差别轮询时间就越长. (2)poll==>时间复杂度O(n) poll本质上和select没有区别,它将用户传入的数组拷贝到内核空间,然后查询每个fd对应的设备状态, 但是它没有最大连接数的限制,原因是它是基于链表来存储的

nginx 多进程 + io多路复用 实现高并发

一.nginx 高并发原理 简单介绍:nginx 采用的是多进程(单线程) + io多路复用(epoll)模型 实现高并发 二.nginx 多进程 启动nginx 解析初始化配置文件后会 创建(fork)一个master进程 之后 这个进程会退出 master 进程会 变为孤儿进程 由init进程托管.(可以通过python 或php 启动后创建子进程,然后杀死父进程得见子进程会由init进程托管) 如下图可以看到nginx master 进程由init(ppid 为1 )进程管理. maste

python之IO多路复用(二)——select、poll、epoll详解

select,poll,epoll都是IO多路复用的机制.I/O多路复用就是通过一种机制使一个进程可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),能够通知程序进行相应的读写操作. select,poll,epoll本质上都是同步I/O,因为他们都需要在读写事件就绪后自己负责进行读写,也就是说这个读写过程是阻塞的 异步I/O则无需自己负责进行读写,异步I/O的实现会负责把数据从内核拷贝到用户空间.   sellect.poll.epoll三者的区别 : select通过一个sel

IO多路复用:select、poll、epoll示例

一.IO多路复用 所谓IO多路复用,就是通过一种机制,一个进程可以监视多个描述符,一旦某个描述符就绪(一般是读就绪或者写就绪),能够通知程序进行相应的读写操作. Linux支持IO多路复用的系统调用有select.poll.epoll,这些调用都是内核级别的.但select.poll.epoll本质上都是同步I/O,先是block住等待就绪的socket,再是block住将数据从内核拷贝到用户内存. 当然select.poll.epoll之间也是有区别的,如下表: \ select poll e