linux epoll

最新推荐文章于 2019-09-02 23:13:12 发布
最新推荐文章于 2019-09-02 23:13:12 发布
阅读量647 收藏
点赞数
分类专栏： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gkyh899/article/details/12982713
版权
1. struct epoll_event

 结构体epoll_event被用于注册所感兴趣的事件和回传所发生待处理的事件，定义如下：

    typedef union epoll_data {
        void *ptr;
         int fd;
         __uint32_t u32;
         __uint64_t u64;
     } epoll_data_t;//保存触发事件的某个文件描述符相关的数据

     struct epoll_event {
         __uint32_t events;      
         epoll_data_t data;      
     };

   其中events表示感兴趣的事件和被触发的事件，可能的取值为：
   EPOLLIN：表示对应的文件描述符可以读；
   EPOLLOUT：表示对应的文件描述符可以写；
   EPOLLPRI：表示对应的文件描述符有紧急的数可读；

   EPOLLERR：表示对应的文件描述符发生错误；
   EPOLLHUP：表示对应的文件描述符被挂断；
   EPOLLET：    ET的epoll工作模式；


epoll_data:

epoll_data中的fd是文件描述符

ptr提供了一个用户可用的指针


关于u32和u64是为了对齐，保证这个联合体长度为8个字节。

看了一下sys_epoll_x的实现，可以看到内核里epoll_event的定义


struct epoll_event {

    __u32 events;

    __u64 data;

  }

因为ptr是一个指针，32位平台下指针长度u32,64BIT平台下指针长度是u64,这个是起到标识作用吧


所涉及到的函数有：

2、epoll_create函数
    函数声明：int epoll_create(int size)
   
   功能：该函数生成一个epoll专用的文件描述符，其中的参数是指定生成描述符的最大范围；


3、epoll_ctl函数
    函数声明：int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
   
    功能：用于控制某个文件描述符上的事件，可以注册事件，修改事件，删除事件。
   
    @epfd：由epoll_create生成的epoll专用的文件描述符；
   
     @op：要进行的操作，EPOLL_CTL_ADD注册、EPOLL_CTL_MOD修改、EPOLL_CTL_DEL删除；
    
     @fd：关联的文件描述符；
    
    @event：指向epoll_event的指针；
   
   成功：0；失败：-1


4、epoll_wait函数
   函数声明:int epoll_wait(int epfd,struct epoll_event * events,int maxevents,int timeout)
  
   功能：该函数用于轮询I/O事件的发生；
  
    @epfd：由epoll_create生成的epoll专用的文件描述符；
   
    @epoll_event：用于回传代处理事件的数组；
   
    @maxevents：每次能处理的事件数；
   
    @timeout：等待I/O事件发生的超时值；
   
   成功：返回发生的事件数；失败：-1


epoll sever 示例


//   

// a simple echo server using epoll in linux  

//   

// author：sunny  

//

// email： gkyh@outlook.com

//   

#include <sys/signal.h>

#include <sys/socket.h>  

#include <sys/epoll.h>  

#include <netinet/in.h>  

#include <arpa/inet.h>  

#include <fcntl.h>  

#include <unistd.h>  

#include <stdio.h>  

#include <errno.h>  

#include <iostream> 

#include <string.h>

#include <stdlib.h>

#include <pthread.h>

#include <sys/wait.h>

#include <sys/types.h>

#include <sys/time.h>

#include <sys/resource.h>

#include <sys/ipc.h>

#include <sys/sem.h>

#include <sys/msg.h>

#include <netdb.h>

#include <unistd.h>

#include <stdarg.h>

#include <time.h>

#include <fcntl.h>



#define SERVICE "epollserver"

#define BUFSIZE 1024

#define TIMEOUT 30

#define PORT 7888

#define     STACKSIZE   81940



#define MAX_EVENTS 1024  

#define MAX_THREAD 300  



struct myepoll_data {

 int fd; 

 int epollFd;

 int epollFd2;

 int len;

 void *data; 

};


static pthread_rwlock_t rwlock;


int iThreadCount;


int tootal=0;


int InitListenSocket(const char * service,short port);  

void AcceptConn(int g_epollFd,int fd);  


void RecvData(int g_epollFd,int g_sendFd,int fd);  

void SendData(int g_sendFd,int fd, char* buf,int len);


void *writeThread(void *arg);

void *readThread(void *arg);



int main(int argc, char **argv)  

{  

 

    int listenFd = InitListenSocket(SERVICE,PORT);  

printf("server running:port[%d]\n", PORT);  


int child =0;

int num_childs=5;

while(!child)

{

if(num_childs>0)

{

switch(fork())

{

case -1:

printf("error in fork!");

return -1;

case 0:

printf("i am the child process, my process id is %d\n",getpid()); 

child=1;

break;

default:

num_childs--;

break;


}


}


}

// fork 5 个子进程

// create epoll 

struct epoll_event ev = {0, {0}};


    int g_epollFd = epoll_create(MAX_EVENTS);  

    if(g_epollFd <= 0)

printf("create epoll failed.%d\n", g_epollFd);


int g_sendFd = epoll_create(MAX_EVENTS);  

    if(g_sendFd <= 0)

printf("create epoll failed.%d\n", g_sendFd);


ev.events = EPOLLIN | EPOLLET;

    ev.data.fd = listenFd;


if (epoll_ctl(g_epollFd, EPOLL_CTL_ADD,listenFd, &ev) < 0) {

        

printf("epoll set insertion error: fd=%d\n", listenFd);

        exit(1);

    }else

        printf("listen socket add epoll complete!\n");


    // event loop  

    struct epoll_event events[MAX_EVENTS];  


iThreadCount = 0;

pthread_t tid,r_tid;

pthread_attr_t attr; 


    if ( pthread_attr_init(&attr) != 0)

        return -1;

if(pthread_attr_setstacksize(&attr, STACKSIZE) != 0)  

return -1;  

 

    pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);    

 

if(pthread_create(&r_tid,NULL,writeThread,(void *)g_sendFd)!=0)

{

printf("pthread_create writeThread error [%d]%s\n",errno,strerror(errno));

return -1;

}


//初始化读写锁

    if (pthread_rwlock_init(&rwlock,NULL) != 0)

    {

        perror("rwlock initialization failed");

        return -1; 

    }

    

    while(1){  

        

        // wait for events to happen  

        int fds = epoll_wait(g_epollFd, events, MAX_EVENTS, -1);  

        if(fds < 0){  

            printf("epoll_wait error, exit\n");  

            break;  

        }  

        for(int i = 0; i < fds; i++){  

            

if((events[i].data.fd==listenFd)&&(events[i].events&EPOLLIN)) // accept event

{


printf("AcceptConn Event,process:{%d] \n",getpid());

AcceptConn(g_epollFd,events[i].data.fd);

}else

            if(events[i].events&EPOLLIN) // read event  

            {  

printf("epoll read event[%d]\n",getpid()); 

while(iThreadCount>MAX_THREAD)

{

printf("pthread_create error [%d]\n",iThreadCount);

usleep(500);

}

   struct myepoll_data* md = (myepoll_data*)events[i].data.ptr;


//RecvData(md->epollFd,md->fd);

md->epollFd2=g_sendFd;

if(pthread_create(&tid,&attr,readThread,(void *)md)!=0)

{

printf("pthread_create error [%d]%s\n",errno,strerror(errno));

}


            }

        }  

    }  

    // free resource  

    return 0;  

}   


// accept new connections from clients  

void AcceptConn(int g_epollFd,int fd)  

{  

    struct sockaddr_in sin;  

    socklen_t len = sizeof(struct sockaddr_in);  

    int nfd, i;  

    // accept  

struct epoll_event evt = {0, {0}}; 

    while(1) 

    {

nfd = accept(fd, (struct sockaddr*)&sin, &len); 

if(nfd==-1)

{


if(errno == EAGAIN)//没有连接需要接收了

{

//printf("%s: accept over,EAGAIN: %d\n", __func__, errno); 

break;

}else

{

printf("%s: accept error,errno: %d\n", __func__, errno);

}


}

 

// set nonblocking

if(( fcntl(nfd, F_SETFL, O_NONBLOCK)) < 0)

{

printf("%s: fcntl nonblocking failed:%d\n", __func__, errno);

break;

}


struct myepoll_data* md =(struct myepoll_data*)malloc(sizeof(struct myepoll_data));

md->fd=nfd;

md->epollFd=g_epollFd;


evt.data.ptr=md;

        evt.events=EPOLLIN|EPOLLET;


if(epoll_ctl(g_epollFd,EPOLL_CTL_ADD,nfd, &evt)<0)

{

printf("accept EPOLL_CTL_ADD failed:%d\n", errno);

}  

 

}

 

}  

// receive data  

void RecvData(int g_epollFd,int g_sendFd,int fd)  

{  

    int len;  

    // receive data

char buf[BUFSIZ];


struct epoll_event evt = {0, {0}};

int pos = 0;

while (1)

{

len = read(fd, buf+pos,sizeof(buf)-pos);

 

if(len > 0)

{

//printf("[recv],len:%d\n",len); 

pos += len;

continue ;

}

else if ( len < 0 )

{

//printf("[recv] :ret[%d] errno [%d]\n",len,errno); 

if ( errno == EAGAIN ){

//printf("[recv] complete,len:%d[%s]\n",pos,buf); 

break;

}

else if ( errno == EINTR  ) continue ;

else {

同一连接可能会出现两个客户端主动关闭的事件,一个errno是EAGAIN(11),一个errno是EBADF(9) 

printf("[recv],some error occurs:%d %s\n",errno,strerror(errno)); 

break;}

// some error occurs

}

else // ( len == 0 )

{  

printf("client disconnect\n");  

epoll_ctl(g_epollFd,EPOLL_CTL_DEL,fd, &evt);

close(fd); 

return ;

// client disconnect

}

 

}

 

epoll_ctl(g_epollFd,EPOLL_CTL_DEL,fd, &evt);


len=pos;

    if(len > 0)

    {

        sprintf(buf,"HTTP/1.0 200 OK\r\nContent-type: text/plain\r\n\r\n%s","Hello world!\n");

sleep(3);

struct myepoll_data* md =(struct myepoll_data*)malloc(sizeof(struct myepoll_data));

md->fd=fd;

md->data=buf;

md->epollFd=g_epollFd;

md->len=strlen(buf);


        evt.data.ptr=md;

        evt.events=EPOLLOUT|EPOLLET;

if(epoll_ctl(g_sendFd,EPOLL_CTL_ADD,fd, &evt)<0)

{

printf("SendData EPOLL_CTL_MOD failed:%d\n", errno);

} 

    }  

}  


void SendData(int g_epollFd,int fd, char* buf,int len)  

{  

  //printf("[SendData] [%s]\n",buf);

  int retval,ret;  


  int pos = len;

 

  while(pos>0)

  {

 

  ret = send(fd, buf+len-pos, pos, 0);      

  if(ret>0)

  {

retval += ret;

pos -= ret;

  }else

if(ret < 0)

{  

 

 //收到中断信号，可以继续写，或者等待后续epoll通知，再写。

if(errno == EINTR)

break;


//写缓冲队列已满，等待再写。

if(errno == EAGAIN)

 {


usleep(500);

continue;                               

 }

printf("[SendData errno [%d]%s\n",errno,strerror(errno)); 

break;

}

 

 if(retval == len||pos==0)

 {

//printf("[SendData complete,len:%d][%s]\n",len,buf); 

break;

 }


  }



    struct epoll_event evt = {0, {0}};


tootal++;

printf("disconnect [%d][%d]\n",getpid(),tootal);  

epoll_ctl(g_epollFd,EPOLL_CTL_DEL,fd, &evt);

close(fd); 


}  

void *readThread(void *arg)

{

     

pthread_rwlock_wrlock(&rwlock);//获取读取锁

iThreadCount++;

printf("workThread start %d\n",iThreadCount); 

pthread_rwlock_unlock(&rwlock);


struct myepoll_data* md =(struct myepoll_data*)arg;


    RecvData(md->epollFd,md->epollFd2,md->fd);


pthread_rwlock_wrlock(&rwlock);//获取读取锁

iThreadCount--;

pthread_rwlock_unlock(&rwlock);

pthread_exit(NULL);

}

void *writeThread(void *arg)

{

  int g_sendFd= (int)arg;

  struct epoll_event events[MAX_EVENTS];

  while(1){  

        

        // wait for events to happen  

        int fds = epoll_wait(g_sendFd, events, MAX_EVENTS, 500);  

        if (fds == -1)

        {

            if(errno==EINTR)

            {               

                continue;

            }

            

printf("[epoll_wait2]errno=%d,%s\r\n",errno,strerror(errno));

            break;

        }

        else if(fds==0)

        {

            continue;

        }  

        for(int i = 0; i < fds; i++){  

           

            if(events[i].events&EPOLLOUT) // write event  

            {  


  struct myepoll_data* md = (myepoll_data*)events[i].data.ptr; 

  //printf("epoll write event [%d][%d]\n",md->fd,events[i].data.fd);  

               SendData(md->epollFd,md->fd,(char *)md->data,md->len);  

            }  

        }  

    }  

    // free resource  

pthread_exit(NULL);

}

 

int InitListenSocket(const char * service,short port)  

{  

struct servent *pse;

struct protoent *ppe;

struct sockaddr_in sin;


bzero(&sin, sizeof(sin));  

    sin.sin_family = AF_INET;  

    sin.sin_addr.s_addr = INADDR_ANY;  


 

if (pse = getservbyname(service, "tcp"))

sin.sin_port = htons(port);//ntohs((u_short)pse->s_port));

else if((sin.sin_port = htons(port)) == 0)

exit(1);//errexit("can't get service\n");


 

if ((ppe = getprotobyname("tcp")) == 0)exit(1);

//errexit("can't get protocol entry\n");



    int listenFd = socket(AF_INET, SOCK_STREAM, 0);  


if(listenFd==-1)

{

perror("socket");

        exit(1);

}


fcntl(listenFd, F_SETFL, O_NONBLOCK); // set non-blocking  

   

    if(bind(listenFd, (const sockaddr*)&sin, sizeof(sin))==-1)

{

perror("bind");

        exit(1);

}

    if(listen(listenFd, 50)==-1)

{

perror("listen");

        exit(1);

}

 

printf("server listen fd=%d\n", listenFd);  


return listenFd;

   

}  


gkyh899
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux条件下利用epoll 接收串口数据
12-13
linux系统下，利用epoll接收串口助手发来的数据并打印。
谈谈select&poll&epoll.docx
02-05
在Linux系统中，当面临需要同时管理大量网络连接或文件描述符时，`select`、`poll`和`epoll`是三种常见的I/O多路复用技术，它们允许程序在一个单独的线程中等待多个文件描述符的事件，提高了程序的效率和并发能力。...
浅析linux中的fork、vfork和clone
weixin_33782386的博客
06-28 134
     各种大神的混合，做个笔记。                 http://blog.sina.com.cn/s/blog_7598036901019fcg.html                           http://blog.csdn.net/kennyrose/article/details/7532912                            h...
关于epoll中event.data联合体的疑问解决方法
sun_z_x的专栏
03-30 2960
http://www.myexception.cn/c/225579.html 关于epoll中event.data联合体的疑问 typedef union epoll_data {   void *ptr;   int fd;   uint32_t u32;   uint64_t u64; } epoll_data_t;   struct epoll_event
Linux&nbsp;epoll简介（转载）
zhangatm的博客
09-11 171
原文地址：http://blog.csdn.net/sparkliang/article/details/4770655 1. Epoll是何方神圣？ Epoll可是当前在Linux下开发大规模并发网络程序的热门人选，Epoll 在Linux2.6内核中正式引入，和select相似，其实都I/O多路复用技术而已，并没有什么神秘的。 其实在Linux下设计并发网络程序，向来不缺少方法，比如
poll&&epoll实现分析（一）——poll实现
BangBang的博客
03-12 234
0.等待队列 在Linux内核中等待队列有很多用途，可用于中断处理、进程同步及定时。我们在这里只说，进程经常必须等待某些事件的发生。等待队列实现了在事件上的条件等待:&nbsp;希望等待特定事件的进程把自己放进合适的等待队列，并放弃控制全。因此，等待队列表示一组睡眠的进程，当某一条件为真时，由内核唤醒它们。 等待队列由循环链表实现，...
linux&nbsp;epoll事件模型详解（转载）
zhangatm的博客
09-11 417
一、介绍     epoll是Linux(内核版本2.6及以上支持)下多路复用IO接口select/poll的增强版本，它能显著提高程序在大量并发连接中只有少量活跃的情况下的系统CPU利用率，因为它会复用文件描述符集合来传递结果而不用迫使开发者每次等待事件之前都必须重新准备要被侦听的文件描述符集合，另一点原因就是获取事件的时候，它无须遍历整个被侦听的描述符集，只要遍历那些被内核IO事件异步唤醒而
poll&&epoll实现分析（二）——epoll实现
BangBang的博客
03-12 196
Epoll实现分析——作者：lvyilong316 通过上一章分析，poll运行效率的两个瓶颈已经找出，现在的问题是怎么改进。首先，如果要监听1000个fd，每次poll都要把1000个fd&nbsp;拷入内核，太不科学了，内核干嘛不自己保存已经拷入的fd呢？答对了，epoll就是自己保存拷入的fd，它的API就已经说明了这一点——不...
关于单机最大tcp连接数&nbsp;及&nbsp;linux&nbsp;…
danssion的专栏
06-25 453
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <div id="content" class= "content mod-cs-content text-content clearfi
redis与linux系统调用epoll
zilong230905的专栏
09-02 349
&nbsp; &nbsp; &nbsp; &nbsp;redis 是一个单线程却性能非常好的内存数据库， 主要用来作为缓存系统。 redis 采用linux网络IO多路复用技术(epoll)来保证在多连接的时候， 系统的高吞吐量。redis的高并发与epoll介绍如下： redis的高并发的原因： 1）绝大部分请求是内存操作，非常快速 2）单线程，避免了不必要的上下文切换 3）IO内部实现采用l...
改进版的poll&nbsp;epoll
10-18 350
Epoll是Linux内核为处理大批量句柄而作了改进的poll。要使用epoll只需要这三个系统调用：epoll_create(2)， epoll_ctl(2)， epoll_wait(2)。它是在2.5.44内核中被引进的(epoll(4) is a new API introduced in Linux kernel 2.5.44)，在2.6内核中得到广泛应用，例如LigHttpd。 epo
linux epoll多线程编程 例子
01-19
在Linux系统中，epoll是I/O多路复用技术的一种高效实现，它极大地改进了传统的轮询方式，尤其在处理大量并发连接时表现出色。本文将深入探讨如何在多线程环境中使用epoll进行程序设计，以提高系统的并行处理能力。 ...
linux socket tcp epoll使用教程 例子 源代码
01-22
linux socket tcp epoll使用教程 例子 源代码
Linux C epoll.zip
05-26
在Linux系统中，`epoll`是一个用于处理大量并发I/O事件的高效机制，尤其适用于网络服务器。这个压缩包文件“Linux C epoll.zip”显然包含了使用C语言编写的服务器（server）和客户端（client）程序，这些程序利用了...
Linux系统下SoftEther的使用方法
热门推荐
gkyh899的专栏
10-23 1万+
softether 现开放了免费版本升级版，支持windows ,linux,mac平台，功能等同与收费的PacketiX VPN 3.0版本。 是日本筑波大学开发的学术项目，发布有中文版本而且兼容PacketiX VPN和UT-VPN（以前用的UT-VPN server 和PacketiX client，但UT-VPN 只有日文版） 1下载地址 http://www.softether-do
debian优化精简
gkyh899的专栏
10-23 2460
1.删除多余组件 apt-get -y purge apache2-* bind9-* xinetd samba-* nscd-* portmap sendmail-* sasl2-bin apt-get -y purge lynx memtester unixodbc python-* odbcinst-* sudo tcpdump ttf-* bind9-* //dns服务器,
samba中文乱码问题&nbsp;常用的配置
gkyh899的专栏
10-23 2222
samba中文乱码问题终极篇 2007年11月06日 星期二 10:15 环境：redhat as 3 up 3 vi /etc/samba/smb.conf 根据locales的设置，修改该文件： 1. 如果locale是zh_CN.UTF-8，做如下设置： display charset = utf8 unix charset = utf8 dos charset = ut
centos6.3安装rtorrent
gkyh899的专栏
10-23 1843
centos6.3安装rtorrent需要自己编译安装 1.下载编译时需要的软件 yum install gcc gcc-c++ m4 make automake libtool pkgconfig perl openssl-devel ncurses-devel cppunit-devel 2.下载 curl, libsigc++, libtorrent 和 rtorrent wg
Linux内核epoll实现解析
"Linux之epoll实现" 本文档主要探讨Linux系统中的epoll机制及其实现，它是Linux下高效I/O事件通知的接口，适用于高并发、高性能的网络服务。epoll是对传统select和poll的改进，旨在解决它们在处理大量文件描述符时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值