epoll 反应堆模型 linux网络编程

最新推荐文章于 2024-08-05 18:19:08 发布
最新推荐文章于 2024-08-05 18:19:08 发布
阅读量97 收藏
点赞数
分类专栏： Linux网络编程 文章标签： epoll socket 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24447809/article/details/109389234
版权

相比较epoll普通模式
主要的改进有以下：
1.利用了epoll_event结构体里的data.ptr(泛型指针)，加入红黑树时能携带自己的信息和相应的回调函数。在epoll_wait()函数返回就绪事件时能执行相应回调函数。

The struct epoll_event is defined as:

           typedef union epoll_data {
               void    *ptr;
               int      fd;
               uint32_t u32;
               uint64_t u64;
           } epoll_data_t;

           struct epoll_event {
               uint32_t     events;    /* Epoll events */
               epoll_data_t data;      /* User data variable */
           };

2.在响应客户端信息请求时，先把对应节点从红黑树上摘除，修改(data.ptr)其属性为可写事件（为了保证客户端处于可接受状态，例如tcp通信中的滑动窗口技术可能导致缓存不够）。当下一次epoll_wait()函数返回时，判断事件为可写事件，向客户端发送数据，把节点从红黑树上摘下，修改(data.ptr)其属性为可读事件，再次加入红黑树中，等待下一次epoll_wait()函数返回。

服务器端

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/types.h>
#include<arpa/inet.h>
#include<errno.h>
#include<string.h>
#include<time.h>
#include<sys/socket.h>
#include<sys/epoll.h>

#define MAX_EVENTS  1024  //监听上限数
#define BUFLEN 4096
#define SERV_PORT 6666

void recvdata(int fd,int events,void * arg);
void senddata(int fd,int events,void * arg);
void initlistensocket(int,short);
void eventset(struct myevent_s *,int,void(*)(int,int,void *),void *);
void eventadd(int ,int,struct myevent_s *);
void acceptconn(int,int,void*);    //处理新连接请求
void eventdel(int ,struct myevent_s *);

struct myevent_s{
    int fd;           //要监听的文件描述符
    int events;      //对应监听事件
    void *arg;       //泛型参数
    void(*call_back)(int fd,int events,void *arg);   //回调函数
    int status;      //是否在监听:1->在红黑树上，2->不在
    char buf[BUFLEN];
    int len;
    long last_active;   //记录每次加入红黑树的时间

};

int g_efd;       //保存epoll_create返回的文件描述符
struct myevent_s g_events[MAX_EVENTS+1];    //自定义结构数组


int main(int argc,char *argv[])
{
    unsigned short port=SERV_PORT;
    if(argc==2)
        port=atoi(argv[1]);
    g_efd=epoll_create(MAX_EVENTS+1);   //创建红黑树
    if(g_efd<=0)
        printf("create efd in %s err %s\n",__func__,strerror(errno));//_func_表示当前函数
    initlistensocket(g_efd,port);     //初始化

    struct epoll_event events[MAX_EVENTS+1]; //保存满足就绪条件的文件描述符数组
    printf("server running : port[%d]\n",port);

    int checkpos=0,i;
    while(1)
    {
        /*超时验证，每次测试100个链接，不测试listenfd,当客户端60秒内没有和服务器通信，则关闭此客户端连接*/
        long now=time(NULL);
        for(i=0;i<100;i++,checkpos++)  //一次循环检测100个，使用checkpos控制检测对象
        {
            if(checkpos==MAX_EVENTS)
                checkpos=0;
            if(g_events[checkpos].status != 1)  //不在红黑树上
                continue;
            long duration = now - g_events[checkpos].last_active;//客户端不活跃时间
            if(duration>=60)
            {
                close(g_events[checkpos].fd);
                printf("[fd=%d] timeout \n",g_events[checkpos].fd);
                eventdel(g_efd,&g_events[checkpos]);     //从红黑树中移除
            }
        }

        /*监听红黑树g_efd,将满足的事件的文件描述符加至events数组中，1秒没有事件满足，返回0*/
        int nfd=epoll_wait(g_efd,events,MAX_EVENTS+1,1000);
        if(nfd<0)
        {
            printf("epoll_wait error,exit!");
            exit(1);
        }
        /*使用自定义结构体myevent_s指针，接收联合体data的void *ptr成员*/
        for(i=0;i<nfd;i++)
        {
            struct myevent_s *ev=(struct myevent_s *)events[i].data.ptr;

            if((events[i].events & EPOLLIN)&&(ev->events & EPOLLIN)) //读就绪事件
                ev->call_back(ev->fd,events[i].events,ev->arg);
            if((events[i].events & EPOLLOUT) && (ev->events & EPOLLOUT))//写就绪事件
                ev->call_back(ev->fd,events[i].events,ev->arg);
        }

    }
    return 0;

}

/*结构体成员初始化*/
void eventset(struct myevent_s *ev,int fd,void(*call_back)(int,int,void*),void *arg)
{
    struct myevent_s *evp=(struct myevent_s *)arg;
    ev->fd=fd;
    ev->call_back=call_back;
    ev->events=0;
    ev->arg=arg;
    ev->status=0;
    ev->len=evp->len;
    if(ev->len==0)
        memset(ev->buf,0,sizeof(ev->buf));
    ev->last_active=time(NULL);    //调用eventset的时间
    return;
}
/*删除操作*/

void eventdel(int efd,struct myevent_s *ev)
{
    struct epoll_event epv={0,{0}};

    if(ev->status !=1)
        return;
    epv.data.ptr=ev;
    ev->status=0;
    epoll_ctl(efd,EPOLL_CTL_DEL,ev->fd,&epv);
    printf("event delet ok [fd=%d]\n",ev->fd);
    return;
}


/* 添加操作*/
 void eventadd(int efd, int events,struct myevent_s *ev)
{
    struct epoll_event epv={0,{0}};
    int op;
    epv.data.ptr=ev;
    epv.events=ev->events = events;   //EPOLLIN EPOLLOUT

    if(ev->status == 1)
        op=EPOLL_CTL_MOD;   //已经在树上就修改
    else
    {
        op=EPOLL_CTL_ADD;  //不在就添加
        ev->status=1;
    }
    if(epoll_ctl(efd,op,ev->fd,&epv)<0)
        printf("event add failed [fd=%d],events[%d]\n",ev->fd,events);
    else
        printf("event add ok [fd=%d], op=%d ,events[%0X]\n",ev->fd,op,events);
    return;

}
 /*当有文件描述符就绪时，epoll返回，调用该函数，与客户端建立连接*/
void acceptconn(int lfd,int events,void *arg)
{
    struct sockaddr_in clie_addr;
    socklen_t clie_len=sizeof(clie_addr);
    int cfd,i;

    if((cfd=accept(lfd,(struct sockaddr *)&clie_addr,&clie_len))==-1)
    {
        if(errno != EAGAIN &&errno != EINTR)
            /*ignore*/
        printf("%s : accept--%s\n",__func__,strerror(errno));
    return;
    }

    do{
        for(i=0;i<MAX_EVENTS;i++)
            if(g_events[i].status==0)  //从全局变量数组中找一个空位置加入
                break;
        if(i==MAX_EVENTS)
        {
            printf("%s,max connect limit[%d]\n",__func__,MAX_EVENTS);
            break;
        }
        int flag=0;
        flag=fcntl(cfd,F_SETFL,O_NONBLOCK);   //设置非阻塞读方式
        if(flag<0)
        {
            printf("%s:fcntl nonblocking failed, %s\n",__func__,strerror(errno));
            break;
        }
        eventset(&g_events[i],cfd,recvdata,&g_events[i]);  //设置属性
        eventadd(g_efd,EPOLLIN,&g_events[i]);          //将cfd添加到红黑树中，监听事件
    }while(0);
}

/*客户端回调处理信息函数 */
void recvdata(int fd,int events,void *arg)
{
    struct myevent_s *ev=(struct myevent_s *)arg;
    int len;

    len=recv(fd,ev->buf,sizeof(ev->buf),0); //读，同read

    eventdel(g_efd,ev);   //从红黑树上摘除

    if(len>0)
    {
        ev->len=len;
        ev->buf[len]='\0';    //手动添加字符串结束标记
        printf("C[%d] : %s\n",fd,ev->buf);

        eventset(ev,fd,senddata,ev);  //设置该fd回调函数为senddata
        eventadd(g_efd,EPOLLOUT,ev);  //重新加入红黑树，监听可写事件
    }
    else if(len==0)
    {
        close(ev->fd);
        /*ev-g_events 地址相减得到偏移元素位置*/
        printf("[fd=%d]  pos[%ld],closed\n",fd,ev - g_events);
    }
    else
    {
        close(ev->fd);
        printf("recv[fd=%d] error[%d] : %s\n",fd,errno,strerror(errno));
    }

    return;

}

/* 客户端可写的话，发送数据*/
void senddata(int fd,int events,void *arg)
{
    struct myevent_s *ev=(struct myevent_s *)arg;
    int len;
    printf("fd=%d \t ev->buf=%s \t ev->len=%d\n",fd,ev->buf,ev->len);
    
    len=send(fd,ev->buf,ev->len,0);  //发送，同write

    if(len>0)
    {
        printf("send[fd=%d], [len=%d] %s\n",fd,len,ev->buf);
        eventdel(g_efd,ev);          //从红黑树中摘除
        eventset(ev,fd,recvdata,ev); //修改回调函数
        eventadd(g_efd,EPOLLIN,ev);  //重新加入红黑树，监听读事件
        printf("-------------------------------------------\n");
    }
    else
    {
        close(ev->fd);
        eventdel(g_efd,ev);
        printf("send[fd=%d] error %s\n",fd,strerror(errno));
    }

    return;
}
void initlistensocket(int efd,short port)
{
    int lfd=socket(AF_INET,SOCK_STREAM,0);
    fcntl(lfd,F_SETFL,O_NONBLOCK);   //设置非阻塞读方式

    /* void eventset(struct myevent_s *ev,int fd,void (*call_back)(int,int,void*),void *arg);*/
    eventset(&g_events[MAX_EVENTS],lfd,acceptconn,&g_events[MAX_EVENTS]);
    //服务器监听新客户端的文件描述符放在数组最后位置
    //回调函数传入的参数也是自己本身

    /* void eventadd(int efd, int events,struct myevent_s *ev)*/
    eventadd(efd,EPOLLIN,&g_events[MAX_EVENTS]);
   
    int opt=1;
    setsockopt(lfd,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));//端口复用
    struct sockaddr_in serv_addr;
    memset(&serv_addr,0,sizeof(serv_addr));
    serv_addr.sin_family =AF_INET;
    serv_addr.sin_addr.s_addr=INADDR_ANY;
    serv_addr.sin_port=htons(port);

    bind(lfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));

    listen(lfd,128);
    return;

}

客户端

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<ctype.h>
#include<arpa/inet.h>
#include<string.h>

#define SERV_IP "127.0.0.1"
#define SERV_PORT  6666
int main()
{
    int cfd,sfd;
    struct sockaddr_in serv_addr;
    socklen_t serv_addr_len;
    char buf[BUFSIZ],clien_ip[BUFSIZ];
    int n;
    char *find;

    memset(&serv_addr,0,sizeof(serv_addr));
    serv_addr.sin_family=AF_INET;
    serv_addr.sin_port=htons(SERV_PORT);//转换为网络字节序
    //serv_addr.sin_addr.s_addr=htonl(INADDR_ANY);//INADDR_ANY可以自行寻找ip
    inet_pton(AF_INET,SERV_IP,&serv_addr.sin_addr.s_addr);

    cfd=socket(AF_INET,SOCK_STREAM,0);//创建本地套接字

    // bind(lfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr));//绑定,客户端隐式绑定

    connect(cfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr) );

    while(1)
    {
        memset(buf,0,sizeof(buf));
        fgets(buf,sizeof(buf),stdin);//从输入端读一行数据存入缓存区中
        find=strchr(buf,'\n');
        if(find)
            *find='\0';//去掉fgets中的换行符
        write(cfd,buf,strlen(buf));
        n=read(cfd,buf,sizeof(buf));
        write(STDOUT_FILENO,buf,n);
        printf("\n");
    }   
    close(cfd);
    return 0;
}

测试结果

客户端
在这里插入图片描述服务器端
在这里插入图片描述

Mr.禾
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
epoll反应堆模型
09-20
epoll c++ linux 技术探讨，新手必备 epoll c++ linux 技术探讨，新手必备 epoll c++ linux 技术探讨，新手必备
epoll reactor 模型详解
柴三少_
09-08 3376
/* *epoll基于非阻塞I/O事件驱动 * 反应堆模型 */ #include #include #include #include #include #include #include #include #include #include #define MAX_EVENTS 1024
alin的学习之路（Linux网络编程：五）（epoll ET\LT模式、epoll反应堆模型）
alin的博客
08-04 235
alin的学习之路（Linux网络编程：五）（epoll ET\LT模式、epoll反应堆模型） 1. epoll ET/LT模式 ET：边沿触发 LT（默认）：水平触发（持续触发） 1. ET模式 边沿触发。 缓冲区 剩余未读尽的数据， 不会导致 epoll_wait 返回。 新的事件满足，会触发epoll_wait 返回。 Epoll 的 ET模式 是高效模式。 但是 ，只支持 非阻塞 O_NONBLOCK 方式 。 —— 轮询。 设置方法： struct epoll_event event;
Linux网络编程，包括tcp/upd，select/poll/epoll/pdf
04-14
linux网络编程 pdf # Linux网络编程基础 Linux网络编程是指在Linux操作系统上开发网络应用程序的过程。它主要涉及到TCP/UDP协议以及select/poll/epoll等多路复用技术。 TCP/UDP协议是网络通信的基础，其中TCP协议...
epoll_loop.c epoll模型反应堆
09-04
epoll反应堆模型代码，相对于网上普通的epoll模型增加了send recv 操作，并有详细的注释epoll反应堆
C/S反应堆模型 socket网络编程
11-16
在IT行业中，网络编程是构建分布式系统的基础，而C/S（Client/Server）反应堆模型则是其中一种常用的设计模式。本文将深入探讨“C/S反应堆模型”在socket网络编程中的应用，以及如何使用C++语言实现这一模型。 首先...
Linux操作系统下epoll反应堆代码
07-26
本压缩包包含了一个关于epoll反应堆的实践代码示例，包括服务器端和客户端的实现，以及Makefile文件，方便编译执行。 1. **epoll简介** - epoll是Event Poll的缩写，主要在Linux 2.5版本之后引入，提供了基于事件...
Linux网络——深入理解 epoll
m0_75186846的博客
08-04 804
定义一个包含多个成员的结构体，并定义一个该结构体类型的变量。
select、poll、epoll
qq_57259389的博客
08-03 351
select是Linux中常用的多路复用IO机制，它允许程序同时监控多个文件描述符（可以是套接字socket，也可以是普通文件）的读、写和异常事件。//参数：//maxfd：监视对象文件描述符数量。//readset：将所有关注“是否存在待读取数据”的文件描述符注册到fd_set变量，并传递其地址值。//writeset： 将所有关注“是否可传输无阻塞数据”的文件描述符注册到fd_set变量，并传递其地址值。
frameworks 之Lopper
u011410770的博客
08-04 568
frameworks 之Lopper
多路I/O复用之select、poll、epoll
m0_61990249的博客
08-04 474
多路I/O复用之select、poll、epoll
IO模型思维导图
m0_73564923的博客
07-31 130
4.select只能工作在水平触发模式(低速模式)无法工作在边沿触发模式(高速模式)4.poll只能工作在水平触发模式(低速模式)无法工作在边沿触发模式(高速模式)2.select监听的文件描述符集合在用户层,需要应用层和内核层互相传递数据。3.epoll会直接获得产生事件的文件描述符的信息,而不需要遍历检测。2.poll监听的文件描述符集合在用户层,需要内核层向用户层传递数据。2.epoll监听的事件表在内核中,直接在内核中监测事件效率高。4.epoll既能工作在水平触发模式,也能工作在边沿触发模式。
Linux网络之多路转接——实用的epoll
m0_75186846的博客
08-03 644
多路转接之 epoll 。本篇详细介绍了 epoll 的底层原理，图文结合，使语义表达更加透彻。同时，以 epoll_echo_server 为切入点，详细介绍了使用 epoll 多路转接的必要步骤，并与 select 进行适度比较，以加深读者区分二者的印象。
网络通信模型
qq_38619449的博客
08-04 477
首先，对于TCP通信来说，每个TCP Socket的内核中都有一个发送缓冲区和一个接收缓冲区 接收缓冲区把数据缓存到内核，若应用进程一直没有调用Socket的read方法进行读取，那么该数据会一 直被缓存在接收缓冲区内。不管进程是否读取Socket，对端发来的数据都会经过内核接收并缓存到 Socket的内核接收缓冲区。read所要做的工作，就是把内核接收缓冲区中的数据复制到应用层用户的Buffer里。
纳秒级网络库【四】接口设计
romandion的专栏
07-31 613
重新设计网络库接口，这个非常重要。一则对应用层足够简单友好，二则确保底层能够实现低延迟。 网络库实现可以分为两个大的部分： 1、网络收发，这个容易理解，但对系统底层依赖较高。 2、进程内分发，这个容易被忽视，但在纳秒级网络库中，同样非常重要。 qkitc项目，主要实现进程内分发。一次echo收发，延迟从前一版本的2微妙降到当前版本的500纳秒，可以接受。
五种IO模型（阻塞，非阻塞，多路复用[select, poll, epoll]，信号驱动，异步IO）
最新发布
qq_74276498的博客
08-05 314
select，poll，epoll，五种IO模型，阻塞，非阻塞，信号驱动，异步IO，多路转接，
62 多路转接epoll
qq_43422358的博客
08-02 1008
当返回值大于0时说明有事件就绪，调用分配函数。例如，典型的一个需要处理上万个客户端的服务器，例如各种互联网app的入口服务器，这样的服务器很适合epoll，如果只是系统内部，服务器和服务器之间通信，只有少数几个连接，这种情况下用epoll不合适，具体根据需求和场景决定使用哪种io模型。多线程或多进程环境下，多个线程同时监听socket，当新链接请求到来，os不知道派哪个线程处理，干脆将其中几个线程都唤醒，实际上只有一个线程能成功处理accept，其他线程都失败，错误码EAGAIN，这种现象称为。
服务器并发模型
m0_70493759的博客
07-31 928
单循环服务器：服务器在同一时刻只能响应一个客户端的请求并发服务器模型：服务器在同一时刻可以响应多个客户端的请求UDP:无连接TCP:有连接1.多进程资源空间消耗大效率低2.多线程相对进程资源消耗小效率较高3.IO多路复用：为了解决进程或线程阻塞到某个 I/O 系统调用而出现的技术，使进程不阻塞于某个特定的 I/O 系统调用。优势：系统开销小，系统不需要建立新的进程或者线程，也不必维护这些线程和进程。多进程并发服务器多线程并发服务器。
什么是IO多路复用？其原理和用途是什么？
xu710263124的博客
08-01 574
IO多路复用
epoll反应堆模型总述
04-18
epoll反应堆模型是一种高效的I/O多路复用机制，常用于服务器端的网络编程。它通过将I/O事件的处理交给操作系统内核来实现高并发和高性能。 在epoll反应堆模型中，主要有以下几个关键组件： 1. 文件描述符（File ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值