epoll和select的例程代码

最新推荐文章于 2024-04-09 21:51:36 发布
最新推荐文章于 2024-04-09 21:51:36 发布
阅读量293 收藏 2
点赞数
分类专栏： C语言 源码

epoll.c

​
#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/epoll.h>

int main()
{
    int epollfd = epoll_create(512);

    int fd_key = open("/dev/input/event1", O_RDONLY|O_NONBLOCK);
    int fd_mice = open("/dev/input/mice", O_RDONLY|O_NONBLOCK);

    struct epoll_event ev;
    ev.events = EPOLLIN; // 监控可读

    ev.data.fd = fd_key; 
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd_key,  &ev);

    ev.data.fd = fd_mice;
    epoll_ctl(epollfd, EPOLL_CTL_ADD, fd_mice, &ev);

    struct epoll_event evout[2];
    char buf[1024];
    while(1)
    {
        int ret = epoll_wait(epollfd, evout, 2, 5000);
        if(ret == 0) continue; // 超时
        if(ret < 0 && errno == EINTR) continue; // 被信号打断
        if(ret < 0) break; // 错误发生了

        // ret > 0情况
        int i;
        for(i=0; i<ret; ++i)
        {
            int fd = evout[i].data.fd;
            if(read(fd, buf, sizeof(buf)) < 0)
            {
                // close自动将它从epoll中移除
                close(fd); 
            }

            if(fd == fd_key) printf("键盘有消息\n");
            else if(fd == fd_mice) printf("鼠标有消息\n");
        }
    }
}

​

 

select.c

#include<stdio.h>
#include<stdlib.h>
#include<fcntl.h>
#include<sys/stat.h>
#include<sys/types.h>
#include<sys/select.h>

int main()
{
    int fd_mice = open("/dev/input/mice", O_RDONLY);
    int fd_key = opeb("/dev/input/event1",O_RDONLY);
    char buf[1024];
    fd_set readfds;  //申请一个文件描述符集合

    while(1)
    {   
        FD_ZERO(&readfds);  //清空集合
        FD_SET(fd_mice,&readfds);  //把fd_mice添加到集合
        FD_SET(fd_key,&readfds);

        struct timeval timeout;
        timeout.tv_sec = 5;
        timeout.tv_usec = 5;

        int ret = select(1024, &readfds, NULL, NULL, &timeout);
        if(ret==0) continue; //阻塞超时,无就绪
        if(ret<0 && errno == EINTR) continue; //被信号打断
        if(ret <0) break; //错误

        if(FD_ISSET(fd_key, &readfds))
        {
            read(fd_key, buf, sizeof(buf));
            printf("keyboard event");
        }
        if(FD_ISSET(fd_mice, &readfds))
        {
            read(fd_mice, buf, sizeof(buf));
            printf("keyboard event");
        }
    }
}

 

sever.c

 #include <stdio.h>
   #include <stdlib.h>
   #include <string.h>
   #include <errno.h>
   
   #include <netinet/in.h>
   #include <sys/socket.h>
   #include <arpa/inet.h>
   #include <sys/epoll.h>
  #include <unistd.h>
  #include <sys/types.h>
  
  #define IPADDRESS   "127.0.0.1"
  #define PORT        8787
  #define MAXSIZE     1024
  #define LISTENQ     5
  #define FDSIZE      1000
  #define EPOLLEVENTS 100
  
  //函数声明
  //创建套接字并进行绑定
  static int socket_bind(const char* ip,int port);
  //IO多路复用epoll
  static void do_epoll(int listenfd);
  //事件处理函数
  static void
  handle_events(int epollfd,struct epoll_event *events,int num,int listenfd,char *buf);
  //处理接收到的连接
  static void handle_accpet(int epollfd,int listenfd);
  //读处理
  static void do_read(int epollfd,int fd,char *buf);
  //写处理
  static void do_write(int epollfd,int fd,char *buf);
  //添加事件
  static void add_event(int epollfd,int fd,int state);
  //修改事件
  static void modify_event(int epollfd,int fd,int state);
  //删除事件
  static void delete_event(int epollfd,int fd,int state);
  
  int main(int argc,char *argv[])
  {
      int  listenfd;
      listenfd = socket_bind(IPADDRESS,PORT);  //创建套接字并进行绑定
      listen(listenfd,LISTENQ);
      do_epoll(listenfd);
      return 0;
  }
  
  static int socket_bind(const char* ip,int port)
  {
      int  listenfd;
      struct sockaddr_in servaddr;
      listenfd = socket(AF_INET,SOCK_STREAM,0);
      if (listenfd == -1)
      {
          perror("socket error:");
          exit(1);
      }
      bzero(&servaddr,sizeof(servaddr));
      servaddr.sin_family = AF_INET;
      inet_pton(AF_INET,ip,&servaddr.sin_addr);
      servaddr.sin_port = htons(port);
      if (bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
      {
          perror("bind error: ");
          exit(1);
      }
      return listenfd;
  }
  
  static void do_epoll(int listenfd)
  {
      int epollfd;
      struct epoll_event events[EPOLLEVENTS];
      int ret;
      char buf[MAXSIZE];
      memset(buf,0,MAXSIZE);
      //创建一个描述符
      epollfd = epoll_create(FDSIZE);
      //添加监听描述符事件
      add_event(epollfd,listenfd,EPOLLIN);
      for ( ; ; )
      {
          //获取已经准备好的描述符事件
          ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1);
          handle_events(epollfd,events,ret,listenfd,buf);
      }
      close(epollfd);
  }
  
  static void
  handle_events(int epollfd,struct epoll_event *events,int num,int listenfd,char *buf)
  {
      int i;
      int fd;
      //进行选好遍历
      for (i = 0;i < num;i++)
      {
         fd = events[i].data.fd;
         //根据描述符的类型和事件类型进行处理
         if ((fd == listenfd) &&(events[i].events & EPOLLIN))
             handle_accpet(epollfd,listenfd);
         else if (events[i].events & EPOLLIN)
             do_read(epollfd,fd,buf);
         else if (events[i].events & EPOLLOUT)
             do_write(epollfd,fd,buf);
     }
 }
 static void handle_accpet(int epollfd,int listenfd)
 {
     int clifd;
     struct sockaddr_in cliaddr;
     socklen_t  cliaddrlen;
     clifd = accept(listenfd,(struct sockaddr*)&cliaddr,&cliaddrlen);
     if (clifd == -1)
         perror("accpet error:");
     else
     {
         printf("accept a new client: %s:%d\n",inet_ntoa(cliaddr.sin_addr),cliaddr.sin_port);
         //添加一个客户描述符和事件
         add_event(epollfd,clifd,EPOLLIN);
     }
 }
 
 static void do_read(int epollfd,int fd,char *buf)
 {
     int nread;
     nread = read(fd,buf,MAXSIZE);
     if (nread == -1)
     {
         perror("read error:");
         close(fd);
         delete_event(epollfd,fd,EPOLLIN);
     }
     else if (nread == 0)
     {
         fprintf(stderr,"client close.\n");
         close(fd);
         delete_event(epollfd,fd,EPOLLIN);
     }
     else
     {
         printf("read message is : %s",buf);
         //修改描述符对应的事件，由读改为写
         modify_event(epollfd,fd,EPOLLOUT);
     }
 }
 
 static void do_write(int epollfd,int fd,char *buf)
 {
     int nwrite;
     nwrite = write(fd,buf,strlen(buf));
     if (nwrite == -1)
     {
         perror("write error:");
         close(fd);
         delete_event(epollfd,fd,EPOLLOUT);
     }
     else
         modify_event(epollfd,fd,EPOLLIN);
     memset(buf,0,MAXSIZE);
 }
 
 static void add_event(int epollfd,int fd,int state)
 {
     struct epoll_event ev;
     ev.events = state;
     ev.data.fd = fd;
     epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&ev);
 }
 
 static void delete_event(int epollfd,int fd,int state)
 {
     struct epoll_event ev;
     ev.events = state;
     ev.data.fd = fd;
     epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,&ev);
 }
 
 static void modify_event(int epollfd,int fd,int state)
 {
     struct epoll_event ev;
     ev.events = state;
     ev.data.fd = fd;
     epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&ev);
 }

clien.c

    #include <netinet/in.h>
   #include <sys/socket.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    #include <sys/epoll.h>
    #include <time.h>
    #include <unistd.h>
    #include <sys/types.h>
   #include <arpa/inet.h>
   
   #define MAXSIZE     1024
   #define IPADDRESS   "127.0.0.1"
   #define SERV_PORT   8787
   #define FDSIZE        1024
   #define EPOLLEVENTS 20
   
   static void handle_connection(int sockfd);
   static void
   handle_events(int epollfd,struct epoll_event *events,int num,int sockfd,char *buf);
   static void do_read(int epollfd,int fd,int sockfd,char *buf);
   static void do_read(int epollfd,int fd,int sockfd,char *buf);
   static void do_write(int epollfd,int fd,int sockfd,char *buf);
   static void add_event(int epollfd,int fd,int state);
   static void delete_event(int epollfd,int fd,int state);
   static void modify_event(int epollfd,int fd,int state);
   
   int main(int argc,char *argv[])
   {
       int                 sockfd;
       struct sockaddr_in  servaddr;
       sockfd = socket(AF_INET,SOCK_STREAM,0);
       bzero(&servaddr,sizeof(servaddr));
       servaddr.sin_family = AF_INET;
       servaddr.sin_port = htons(SERV_PORT);
       inet_pton(AF_INET,IPADDRESS,&servaddr.sin_addr);
       connect(sockfd,(struct sockaddr*)&servaddr,sizeof(servaddr));
       //处理连接
       handle_connection(sockfd);
       close(sockfd);
       return 0;
   }
   
   
   static void handle_connection(int sockfd)
   {
       int epollfd;
       struct epoll_event events[EPOLLEVENTS];
       char buf[MAXSIZE];
       int ret;
       epollfd = epoll_create(FDSIZE);
       add_event(epollfd,STDIN_FILENO,EPOLLIN);
       for ( ; ; )
       {
           ret = epoll_wait(epollfd,events,EPOLLEVENTS,-1);
           handle_events(epollfd,events,ret,sockfd,buf);
       }
       close(epollfd);
   }
   
   static void
   handle_events(int epollfd,struct epoll_event *events,int num,int sockfd,char *buf)
   {
       int fd;
       int i;
       for (i = 0;i < num;i++)
       {
           fd = events[i].data.fd;
           if (events[i].events & EPOLLIN)
               do_read(epollfd,fd,sockfd,buf);
           else if (events[i].events & EPOLLOUT)
               do_write(epollfd,fd,sockfd,buf);
       }
   }
   
   static void do_read(int epollfd,int fd,int sockfd,char *buf)
   {
       int nread;
       nread = read(fd,buf,MAXSIZE);
           if (nread == -1)
       {
           perror("read error:");
           close(fd);
       }
       else if (nread == 0)
       {
           fprintf(stderr,"server close.\n");
           close(fd);
       }
       else
       {
           if (fd == STDIN_FILENO)
               add_event(epollfd,sockfd,EPOLLOUT);
           else
           {
               delete_event(epollfd,sockfd,EPOLLIN);
               add_event(epollfd,STDOUT_FILENO,EPOLLOUT);
           }
       }
  }
  
  static void do_write(int epollfd,int fd,int sockfd,char *buf)
  {
      int nwrite;
      nwrite = write(fd,buf,strlen(buf));
      if (nwrite == -1)
      {
          perror("write error:");
          close(fd);
      }
      else
      {
          if (fd == STDOUT_FILENO)
              delete_event(epollfd,fd,EPOLLOUT);
          else
              modify_event(epollfd,fd,EPOLLIN);
      }
      memset(buf,0,MAXSIZE);
  }
  
  static void add_event(int epollfd,int fd,int state)
  {
      struct epoll_event ev;
      ev.events = state;
      ev.data.fd = fd;
      epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&ev);
  }
  
  static void delete_event(int epollfd,int fd,int state)
  {
      struct epoll_event ev;
      ev.events = state;
      ev.data.fd = fd;
      epoll_ctl(epollfd,EPOLL_CTL_DEL,fd,&ev);
  }
  
  static void modify_event(int epollfd,int fd,int state)
  {
      struct epoll_event ev;
      ev.events = state;
      ev.data.fd = fd;
      epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&ev);
  }

 

SuGuolin
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
select、poll、epoll的区别使用示例代码
05-18
Linux系统编程——I/O多路复用select、poll、epoll的区别使用，相关教程如下： http://blog.csdn.net/tennysonsky/article/details/45745887
epoll_create详解
zhoumuyu_yu的博客
01-11 2万+
epoll_create，打开一个epoll文件描述符。 #include <sys / epoll.h> nfd = epoll_creat(max_size); epoll_create（）创建一个epoll实例。其中nfd为epoll句柄，参数max_size标识这个监听的数目最大有多大，从Linux 2.6.8开始，max_size参数将被忽略，但必须大于零。epoll_create（）返回引用新epoll实例的文件描述符。该文件描述符用于随后的所有对epoll的调...
epoll简单示例
qq_42702222的博客
04-01 2371
简单的epoll实例。
IO多路复用---epoll详解及示例
weixin_46566893的博客
12-01 2835
一、epoll系统调用 epoll是Linux特有的I/O复用函数。它的实现和使用上与select、poll有很大的差异。注意epoll是使用一组函数来完成任务的，而不是单个函数。其次，epoll把用户关心的文件描述符上的事件放在内核的一个事件表里面，从而无需像select和poll那样每次调用都要重复传入文件描述符或事件集。 二、内核事件表 首先，epoll需要使用一个额外的文件描述符，来唯一表示内核中的这个事件表，这个文件描述符使用如下函数epoll_create函数来创建： #include&lt
epoll用法详解与编程实例
weixin_43354152的博客
10-11 3433
epoll中三个函数中的相关参数到底应该怎么使用？这篇epoll用法详解与编程实例文章将告诉你。
ACE使用例程
06-07
1. **异步I/O**：ACE支持多种异步I/O模型，如事件多路复用（例如，select、epoll等），使得开发者可以高效地处理大量的并发连接。 2. **线程和进程管理**：提供了一组高级接口来创建、同步和管理线程和进程，简化了...
教你玩转网络编程模型之完成例程(Completion Routine)篇配套代码
02-19
完成例程的主要作用是在I/O操作完成后执行一段用户定义的回调函数，它与传统的基于事件的模型（如select、poll、epoll）不同，不是在I/O准备就绪时触发，而是在I/O实际完成时调用。这种模式提高了系统的效率，因为它...
06Server_socket_通信例程_
10-03
例如，如果服务器需要同时处理多个客户端连接，它可能使用多线程或多进程，或者利用非阻塞I/O和事件驱动编程模型（如select、poll、epoll等）。 在学习和分析这个"06Server_socket_通信例程_"时，我们需要关注代码...
linux网络编程之 epoll简介
11-04
与select和poll相比，epoll提供了更高的灵活性和效率，尤其适合处理大量并发连接的场景。 - **核心特点**： - **无限制的文件描述符**：epoll支持动态添加和删除文件描述符，不受固定数量的限制。 - **边缘触发...
linux socket的select函数例子
10-08
在提供的示例代码中，我们看到了如何使用`select`函数来管理一个监听套接字和多个客户端连接。以下是对关键部分的详细解释： #### 初始化监听套接字 首先，创建一个TCP套接字并将其绑定到特定端口上： ```c int ...
Linux I/O 多路复用之select、poll、epoll详解与代码示例
彼此当年少，莫负好时光
06-27 2227
如果写过最基础的TCP服务，那就应该清楚 accept 和 recv 函数是阻塞式的（默认），也就是说程序就卡在这个地方等待，直到有连接或者数据来到。如果不用多线程的话，一旦有数据到来就会一直处理这个连接的数据，而没法接收新的连接。其实操作系统可以在一个线程里轮询式处理这些事务，也就是常说的I/O多路复用。 select，poll，epoll 都是I/O多路复用的机制。I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。s
epoll的使用示例及其解释
最新发布
天使之翼
04-09 1918
epoll 是 Linux 下的一个 I/O 多路复用机制，用于高效地监听多个文件描述符上的 I/O 事件。相较于 select 和 poll，epoll 在处理大量连接时具有更好的性能。
Linux Epoll介绍和程序实例
热门推荐
sparkliang的专栏
11-05 12万+
Linux Epoll介绍和程序实例1. Epoll是何方神圣？Epoll可是当前在Linux下开发大规模并发网络程序的热门人选，Epoll 在Linux2.6内核中正式引入，和select相似，其实都I/O多路复用技术而已，并没有什么神秘的。其实在Linux下设计并发网络程序，向来不缺少方法，比如典型的Apache模型（Process Per Connection，简称PPC），TPC（Thre
epoll详解（使用、原理、实验）
欢迎来到jiantaoyab博客
02-13 4706
执行epoll_create时，创建了红黑树和就绪链表，执行epoll_ctl时，如果增加socket句柄，则检查在红黑树中是否存在，存在立即返回，不存在则添加到树干上，然后向内核注册回调函数，用于当中断事件来临时向准备就绪链表中插入数据。epoll_wait在调用时，在给定的timeout时间内，当在监控的所有句柄中有事件发生时，就返回用户态的进程,不用传递socket句柄给内核，因为内核已经在epoll_ctl中拿到了要监控的句柄列表。，当有的连接请求的时候，服务器被通知，执行回调函数来建立起连接。
linux epoll介绍和程序实例,Linux epoll源码剖析
weixin_36310976的博客
05-10 154
Linux epoll源码剖析linux内核版本：2.6.34在读epoll源码前，需要先了解的知识点：等待队列文件系统(主要是进程的打开文件描述符表以及struct file)poll机制资源注册监听poll() -> poll_wait(struct file *, wait_queue_t *, poll_table *pt) -> pt->qproc(struct fil...
优于select的epoll
早起的虫儿灬
01-07 327
select与epoll select的缺点 1、在linux系统下单个进程能打开的文件描述符的最大数量有限制(#define __FD_SETSIZE    1024) 2、事件发生后需要遍历注册的所有对象的集合(必须遍历才能知道是谁发生了事件) 3、在每次调用select函数时都要向内核拷贝(注册)需要监视的对象信息(由于函数调用之后会修改描述符的集合，因此再次调用时某些对象相当于相当
epoll完整例子
Make Progress Everyday!
07-18 1086
#include #include #include #include #include #include #include #include #define MAXLINE 100voidsetnonblocking (int sock){  int opts = 0;  opts = fcntl (sock, F_GETFL);  if (opts   {  perror ("fc
epoll使用实例：TCP服务端处理多个客户端请求
码农爱学习的博客
10-30 1610
上篇文章，介绍了Unix域的socket通信，并通过实例测试了TCP和UDP两种传输方式。本篇，在上篇例程的基础上，来学习epoll的多路复用功能，通过给服务端增加epoll监听功能，实现对多个客户端的数据进行接收。
epoll完整实例
liuhongxian的专栏
10-30 1493
转自：http://www.cppblog.com/API/archive/2013/07/01/201424.html epoll完整实例 #include deque> #include map> #include vector> #include pthread.h> #include semaphore.h> #include time.h> #includ
epoll和select
06-10
`epoll` 和 `select` 都是 Linux 中的 I/O 多路复用机制，可以用来实现高并发网络编程。 `select` 是最早的 I/O 多路复用机制，支持监视的文件描述符数量有限，一般是 1024。同时每次调用 `select` 都会遍历所有的文件描述符，效率较低，但是在一些低并发的场景下使用还是很合适的。 `epoll` 是在 `select` 的基础上改进而来，可以支持大量的文件描述符，可以通过 `epoll_create` 函数创建一个 epoll 文件描述符，然后将需要监视的文件描述符加入到 epoll 中，当有事件触发的时候，只需要遍历触发事件的文件描述符即可，效率比 `select` 更高。同时，`epoll` 还支持边缘触发和水平触发两种模式，边缘触发只在状态变化的时候触发，水平触发在状态变化的时候一直触发。 总的来说，`epoll` 在高并发的场景下表现更好，而 `select` 在低并发的场景下表现更好。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值