Linux Socket 编程 --深入理解 epoll 与 Reactor epoll 实现百万并发

已于 2022-08-23 21:55:38 修改
阅读量538 收藏
点赞数
文章标签： linux 运维 服务器
于 2022-08-21 15:37:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wxfx_OT/article/details/126358115
版权

没有Reactor 模式的 epoll

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/epoll.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>

#include <arpa/inet.h>

#define BACKLOG  10
#define BASE_PORT   9999
#define PORT_NUMBER  1
#define EVENTS_LENGTH  1000
#define BUFFER_LENGTH  1024
/*
struct sock_item{
    int fd;
    char * rbuffer;
    int rlength;
    char * wbuffer;
    int wlength;

    int event;

    void (*recv_cb)(int fd,char *buffer,int length);
    void (*send_cb)(int fd,char *buffer,int length);
    void (*accept_cb)(int fd,char *buffer,int length);
     
};

struct eventblock{
    struct sock_item *items;
    struct eventblock* next;

};

struct reactor{
     int epfd;
     int blockcnt;
     struct eventblock* evblk;
};

int reactor_resize(struct reactor * r)
{
    //传参判断
    if(r == NULL)  return -1;
    if(r->evblk == NULL)  return -1;

    struct eventblock *blk = r->evblk;
    while(blk != NULL && blk->next != NULL)
    {
       
    }
}
struct sock_item* reactor_lookup(struct reactor* r,int sockfd)
{
    
}

*/

int Init_Server(short port)
{
    int listenfd;
    struct sockaddr_in servaddr;
    listenfd = socket(AF_INET,SOCK_STREAM,0);
    if(listenfd == -1) 
    {
        printf("create socket error\n"); // 使用 perror最好
        return -1;
    }
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(port);
    if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))==-1) 
    {
        return -2;
    }
    listen(listenfd,BACKLOG);//监听 等待 client连接
    return listenfd;
}

int Is_Serverfd(int *fds,int connfd)
{
    int i = 0;
    for(i =0;i < PORT_NUMBER;i++)
    {
         if(fds[i]==connfd)
        {
            return 1;
        }
    }
    return 0;
}

int main()
{
    int epfd,clientfd;
    struct epoll_event  ev, events[EVENTS_LENGTH];
    int ret;
    char rbuffer[BUFFER_LENGTH] = {0};//所有的fd 公用一个
    char wbuffer[BUFFER_LENGTH] = {0};//所有的fd 公用一个
    int sockfds[PORT_NUMBER]={0};

    epfd = epoll_create(1);
    int i = 0;
    for(i=0;i<PORT_NUMBER;i++)
    {
        sockfds[i]= Init_Server(BASE_PORT + i);
        printf("listen fd:%d\n",sockfds[i]);
        ev.events = EPOLLIN;
        ev.data.fd = sockfds[i];
        if(epoll_ctl(epfd,EPOLL_CTL_ADD,sockfds[i],&ev)== -1)
        {
            printf("err epoll_ctl\n");
        }
    }
    
    while(1)
    {
        int nready = epoll_wait(epfd,events,EVENTS_LENGTH,1000);
        printf("--------nready=%d\n",nready);
        int i=0;
        for(i = 0; i < nready; i++)
        {
            int eventfd = events[i].data.fd;
            printf("No:%d---eventfd:%d\n",i,eventfd);
            // 判断 epoll 返回的活动的 fd 是不是 scokfd,是就 accept 获得 clientfd, 不是 就进入收发流程
            if(Is_Serverfd(sockfds,eventfd)) // 是 serverfd
            {
                struct sockaddr_in client;
                socklen_t len =sizeof(client);
                clientfd= accept(eventfd,(struct sockaddr*)& client,&len);
                char *ip_addr;
                ip_addr= inet_ntoa(*(struct in_addr *)&(client.sin_addr.s_addr));
                printf("Client <%d--%s:%d>\n",clientfd,ip_addr,ntohs(client.sin_port));
                 // 把获取到的Clientfd 也加入到兴趣列表里
                //struct epoll_event ev;
                ev.events= EPOLLIN;
                ev.data.fd = clientfd;
                epoll_ctl(epfd,EPOLL_CTL_ADD,clientfd,&ev);
                
            }else if (events[i].events & EPOLLIN)
            {     
                    memset(rbuffer,0,sizeof(rbuffer));
                    memset(rbuffer,0,sizeof(wbuffer));
                    ret = recv(eventfd,rbuffer,BUFFER_LENGTH,0);
                    if(ret > 0)
                    {
                        rbuffer[BUFFER_LENGTH]='\0';
                        printf("buffer: %s,ret:%d\n",rbuffer,ret);
                        memcpy(wbuffer,rbuffer,BUFFER_LENGTH);
                        memset(rbuffer,0,sizeof(rbuffer));
                        ev.events = EPOLLOUT;
                        ev.data.fd = eventfd;
                        epoll_ctl(epfd,EPOLL_CTL_MOD,eventfd,&ev);
                    }else if(ret == 0){
                        close(eventfd);
                    }

            }
            else if(events[i].events & EPOLLOUT)
            {
                int sent= send(eventfd,wbuffer,ret,0);
                printf("sent:%d\n",sent);
                memset(rbuffer,0,sizeof(rbuffer));
                memset(rbuffer,0,sizeof(wbuffer));
                ev.events = EPOLLIN;
                ev.data.fd = eventfd;
                epoll_ctl(epfd,EPOLL_CTL_MOD,eventfd,&ev);
            }
        }
    }
    return 0;
}

总结

  1. 所有 fd 共用 rbuffer 与 wbuffer ，当并发数量很多，同时读写的时候，如果不加锁就会出现 rbuffer 与 wbuffer 混乱的问题。如果加锁就会影响读写性能。

reactor 模式测试验证

看一下涉及到的 对象

struct reactor / struct eventblock / struct sock_items
在这里插入图片描述

看一下reactor 代码的运行 运行

struct sock_items{
    int fd;
    char *rbuffer;
    int  rlength;
    char *wbuffer;
    int wlength;

    int event;

    void (*recv_cb)(int fd,char *buffer,int length);
    void (*send_cb)(int fd,char *buffer,int length);
    void (*accept_cb)(int fd,char *buffer,int length);

};

struct eventblock{
     struct sock_items*  items;
     struct eventblock* next;
};

struct reactor{
    int epfd;
    int blkcnt; // block 块的数量
    struct eventblock*  evblk; // 指向第一个 eventblock
};

int reactor_resize(struct reactor * r)
{
    if(r == NULL) return -1;
    //if(r->evblk == NULL) return -1;

    struct eventblock * blk = r->evblk;
    struct sock_items* item = (struct sock_items*) calloc(ITEM_LENGTH , sizeof(struct sock_items));
    if(item == NULL) return  -4;

    struct eventblock *block =  (struct eventblock*)calloc(1,sizeof(struct eventblock));
    if(block == NULL)
    {
        free(item);
        return -5;
    }
    memset(block,0,sizeof(struct eventblock));
    block->items = item;
    block->next = NULL;
    if(blk == NULL)
    {
        r->evblk = block;
    }else{
          while(blk !=NULL && blk->next!=NULL)
         {
            blk = blk->next;
         }
         blk->next = block;
    }
    r->blkcnt ++;
    return 0;
}

struct sock_item* reactor_lookup(struct reactor *r,int sockfd)
{
    if ( r== NULL)  return NULL;
    if(sockfd <= 0)  return NULL;

    int blkidx = sockfd / ITEM_LENGTH;
    while(blkidx  >= r->blkcnt)
    {
        reactor_resize(r);
    }
    int i = 0;
    struct eventblock *blk = r->evblk;
    while(i++ < blkidx && blk !=NULL)
    {
        blk = blk->next;
    }
    return &blk->items[sockfd % ITEM_LENGTH];
 
}

// 测试 reactor 能不能正常分配 内存
int main()
	{
	  struct reactor *r = (struct reactor*) calloc(1,sizeof(struct reactor));
	  r->epfd = 1;
	  int i = 1;
	  while(i < 11)
	  {
	    struct sock_items *item = reactor_lookup(r,i);
	    item->fd = i;
	    item->rbuffer = calloc(1,10);
	    item->rlength = 0;
	    item->wbuffer = calloc(1,10);
	    item->wlength = 0;
	    i++;
	  }
	}

请添加图片描述

epoll + Reactor 代码

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <fcntl.h>
#include <pthread.h>
#include <sys/epoll.h>
#include <time.h>
#include <string.h>
#include <stdlib.h>

#include <arpa/inet.h>

#define BACKLOG  10
#define BASE_PORT   9999
#define PORT_NUMBER  1
#define EVENTS_LENGTH  1000
#define BUFFER_LENGTH  1024
#define ITEM_LENGTH  1000

struct sock_items{
    int fd;
    char *rbuffer;
    int  rlength;
    char *wbuffer;
    int wlength;

    int event;

    void (*recv_cb)(int fd,char *buffer,int length);
    void (*send_cb)(int fd,char *buffer,int length);
    void (*accept_cb)(int fd,char *buffer,int length);

};

struct eventblock{
     struct sock_items*  items;
     struct eventblock* next;
};

struct reactor{
    int epfd;
    int blkcnt; // block 块的数量
    struct eventblock*  evblk; // 指向第一个 eventblock
};

int reactor_resize(struct reactor * r)
{
    if(r == NULL) return -1;
    printf("reactor reszie\n");
    struct eventblock * blk = r->evblk;
    struct sock_items* item = (struct sock_items*) calloc(ITEM_LENGTH , sizeof(struct sock_items));
    if(item == NULL) return  -4;

    struct eventblock *block =  (struct eventblock*)calloc(1,sizeof(struct eventblock));
    if(block == NULL)
    {
        free(item);
        return -5;
    }
    memset(block,0,sizeof(struct eventblock));
    block->items = item;
    block->next = NULL;
    if(blk == NULL)  // 第一次 链表里面没有任何节点的时候
    {
        r->evblk = block;
    }else{             // 其他情况下,首先要找到队尾，然后把队尾重新指向 它
        while(blk !=NULL && blk->next !=NULL)
        {
           blk = blk->next;
        }
        blk->next = block;
    }

    r->blkcnt ++;
    return 0;
}

struct sock_item* reactor_lookup(struct reactor *r,int sockfd)
{
    if ( r== NULL)  return NULL;
    if(sockfd <= 0)  return NULL;
    printf("reactor lookup---> %d\n",sockfd);
    int blkidx = sockfd / ITEM_LENGTH;
    //printf("reactor lookup---> %d\n",blkidx);
    while(blkidx  >= r->blkcnt)
    {
        reactor_resize(r);
    }
    int i = 0;
    struct eventblock *blk = r->evblk;
    while(i++ < blkidx && blk !=NULL)
    {
        blk = blk->next;
    }
    return &blk->items[sockfd % ITEM_LENGTH];
 
}

int Init_Server(short port)
{
    int listenfd;
    struct sockaddr_in servaddr;
    listenfd = socket(AF_INET,SOCK_STREAM,0);
    if(listenfd == -1) 
    {
        printf("create socket error\n"); // 使用 perror最好
        return -1;
    }
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port = htons(port);
    if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))==-1) 
    {
        return -2;
    }
    listen(listenfd,BACKLOG);//监听 等待 client连接
    return listenfd;
}

int Is_Serverfd(int *fds,int connfd)
{
    for(int i =0;i < PORT_NUMBER;i++)
    {
         if(fds[i]==connfd)
        {
            return 1;
        }
    }
    return 0;
}


int main()
{
    int epfd,clientfd;
    struct epoll_event  ev, events[EVENTS_LENGTH];
    int ret;
    int sockfds[PORT_NUMBER]={0};
    //char rbuffer[BUFFER_LENGTH] = {0};//所有的fd 公用一个
    //char wbuffer[BUFFER_LENGTH] = {0};//所有的fd 公用一个
    struct reactor  *r = (struct reactor*) calloc(1,sizeof(struct reactor));
    if( r== NULL)
    {
        return -3;
    }
    r->blkcnt = 0;
    r->epfd = epoll_create(1);
    for(int i=0;i<PORT_NUMBER;i++)
    {
        sockfds[i]= Init_Server(BASE_PORT + i);
        printf("listen fd:%d\n",sockfds[i]);
        ev.events = EPOLLIN;
        ev.data.fd = sockfds[i];
        if(epoll_ctl(r->epfd,EPOLL_CTL_ADD,sockfds[i],&ev)== -1)
        {
            printf("err epoll_ctl\n");
        }
    }
    
    while(1)
    {
        int nready = epoll_wait(r->epfd,events,EVENTS_LENGTH,1000);
        //printf("--------nready=%d\n",nready);
        for(int i = 0; i < nready; i++)
        {
            int eventfd = events[i].data.fd;
            // 判断 epoll 返回的活动的 fd 是不是 scokfd,是就 accept 获得 clientfd, 不是 就进入收发流程
            if(Is_Serverfd(sockfds,eventfd)) // 是 serverfd
            {
                printf("is Server fd\n");
                struct sockaddr_in client;
                socklen_t len =sizeof(client);
                clientfd= accept(eventfd,(struct sockaddr*)& client,&len);
                if(clientfd == -1) break;
                // if(clientfd % 1000 == 999){
                //     printf("accept:%d\n",clientfd);
                // }
                char *ip_addr;
                ip_addr= inet_ntoa(*(struct in_addr *)&(client.sin_addr.s_addr));
                printf("Client <%s:%d>\n",ip_addr,ntohs(client.sin_port));
                 // 把获取到的Clientfd 也加入到兴趣列表里
                //struct epoll_event ev;
                ev.events= EPOLLIN;
                ev.data.fd = clientfd;
                epoll_ctl(r->epfd,EPOLL_CTL_ADD,clientfd,&ev);

                struct sock_items *item = reactor_lookup(r,clientfd);// 查找函数
                item->fd = clientfd;
                item->rbuffer = calloc(1,BUFFER_LENGTH);
                item->rlength = 0;
                item->wbuffer = calloc(1,BUFFER_LENGTH);
                item->wlength = 0;
                
            }else if (events[i].events & EPOLLIN)
            {     
                       printf("recv\n");
                       struct sock_items *item = reactor_lookup(r,eventfd);// 查找函数
                       char * rbuffer = item->rbuffer;
                       char * wbuffer = item->wbuffer;
                       ret = recv(item->fd,rbuffer,BUFFER_LENGTH,0);
                       if(ret > 0)
                       {
                         printf("recv %d> 0 \n",ret);
                         rbuffer[BUFFER_LENGTH]='\0';
                         printf("buffer: %s,ret:%d\n",rbuffer,ret);
                         memcpy(wbuffer,rbuffer,BUFFER_LENGTH);
                         ev.events = EPOLLOUT;
                         ev.data.fd = eventfd;
                         epoll_ctl(r->epfd,EPOLL_CTL_MOD,eventfd,&ev);
                       }else if(ret == 0){
                          printf("recv = 0 \n");
                          free(rbuffer);
                          free(wbuffer);
                          item->fd = 0;
                          close(eventfd);
                       }

            }
            else if(events[i].events & EPOLLOUT)
            {
                printf("send\n");
                struct sock_items *item = reactor_lookup(r,eventfd);// 查找函数
                char * rbuffer = item->rbuffer;
                char * wbuffer = item->wbuffer;
                int sent= send(item->fd,wbuffer,ret,0);
                printf("sent:%d\n",sent);
                ev.events = EPOLLIN;
                ev.data.fd = eventfd;
                epoll_ctl(r->epfd,EPOLL_CTL_MOD,eventfd,&ev);
            }
        }
    }
    return 0;
}

测试记录

三客户端简单测试

大链接建链接测试（承载测试）

每个业务的 QPS（吞吐量测试）

断开连接的时候

数据传输量（每秒传送的数据包）

文章参考与<零声教育>的C/C++linux服务期高级架构系统教程学习:
服务器高级架构体系：
https://ke.qq.com/course/417774?flowToken=1010783

wxfx_OT
关注
linux网络编程－高并发服务器
KHY666的博客
12-03 391
linux网络编程－高并发服务器 1.多进程\多线程版高并发服务器(使用与客服端数量不多的情况，不适用与大型开发，该方法需要自己监听\处理对系统资源消耗太大．应用比如智能家居系统．) 2.多路I\O转接服务器（多任务I\O服务器） 核心思想：不再由应用程序自己监听客服端的连接，由内核替代．主要的实现方法有三种： 1> select 2> poll 3> epoll １．多进程\多线程版高并发服务器 1>．多进程版 /**********************************
epoll实现tcp百万级高并发测试源码
12-06
https://blog.csdn.net/u014220105/article/details/84849570 可先参考相关描述，epoll实现tcp百万级高并发测试，代码仅用于测试和功能验证，并不是特别完善，不喜勿喷，欢迎指导
2.2.1使用epoll及reactor实现服务器百万并发
weixin_56220992的博客
10-15 513
使用epoll以及reactor实现服务器百万并发
linux c++ 利用epoll实现百万并发服务器
hw5230的博客
04-21 434
该代码实现了一个简单的echo服务，监听8080端口并回显客户端发送的数据。在每个连接上采用非阻塞Socket，使用epoll模型进行IO复用。同时，通过设置事件为EPOLLET，实现边沿触发模式，避免因为水平触发模式下的重复通知而导致资源浪费。在Linux环境下，通常建议使用多线程并发模型，因为线程之间的切换开销比进程小。使用一个高效的IO复用机制来处理大量连接请求。在Linux环境下，最常用的IO复用机制是epoll。优化代码实现，如减少锁的使用、避免内存泄漏等。
【高并发】单机，Epoll最多可以多少并发，linux最多可以多少并发？
bandaoyu的note
08-11 1538
4G内存的情况： 按照题主的意思 是根据内存去算一个最大并发的连接数. 那么首先要找出来单个连接消耗内存的地方. 第一个首先是socket buffer. read 和write 分别有一个, 默认大小在 代码如下: /proc/sys/net/ipv4/tcp_rmem (for read) /proc/sys/net/ipv4/tcp_wmem (for write) 默认大小都是87K和16K, 最低是4K和4K, 最高是2M,2M, 实际使用默认值最低也要保留8K,8K. 然后是逻辑
epoll单台设备支持百万并发连接
sf_jiang的博客
02-13 686
epoll支持百万并发的demo
深入理解epoll与 reactor模式
"epoll与reactor模式在网络编程中的应用" 在高性能的网络服务器开发中，I/O多路复用技术扮演着至关重要的角色。epoll是Linux内核提供的一种高效I/O事件通知机制，而reactor模式是一种设计模式，用于处理并发I/O事件...
epoll的reactor模型实现
04-20
文件中程序通过C语言，调用了相关的网络socket API完成的一个reactor并发服务器功能。能够实现消息的接收与回发。分析了程序的不同以及各自的特点。 文件解释了epoll与reactor的区别之处，分析了各自的特点。并最后...
Linux下使用EPoll+队列+多线程的C++实现
12-24
`epoll`是Linux内核提供的一种I/O多路复用技术，它极大地提高了处理大量并发连接的效率。`epoll`的主要优点在于它能显著降低系统调用的开销，因为它通过水平触发和边缘触发两种模式，使得程序只需关注有事件发生的...
Linux环境下高并发web服务器-的设计与实现.docx
12-17
总的来说，设计和实现一个Linux环境下的高并发Web服务器需要深入理解网络编程、I/O模型、并发控制和HTTP协议。通过合理地运用这些技术，可以构建出一个高性能、可扩展且稳定的Web服务器，满足大量用户的同时访问需求...
Linux环境SOCKET编程4：Reactor模式
destiny的专栏
09-03 713
1、Reactor模式简介 Wikipedia上说：“The reactor design pattern is an event handling pattern for handling service requests delivered concurrently by one or more inputs. The service handler then demultip...
基于EPOLL的反应堆的百万服务器并发实现
m0_56375727的博客
03-25 205
每一个模块里包含一个block，每个block属于一个结构体数组，这个数组的最大存储的数量为1024,这样我们就可以控制百万级别以上的连接。不能，因为初始化的时候EPOLLOUT是监听写缓冲区的，由于刚开始的缓冲区是空的，这个缓冲区就会可写，一直被触发！当listenfd面对大量的数据的时候，为了避免漏掉连接，我们需要用到水平触发。对于反应堆的结构，主要的是回调函数的设置，而回调函数在结构体数组上能够存储，具体如下图。因为在边缘触发的情况下，一旦有连接或者其他读的事件，就会触发事件的发生。
c语言socket之epoll的reactor模型开发服务器
jenie的专栏
06-23 442
大多数的libevent,libuv,muduo 等开源框架都是基于这种方式实现。只能意会，不能言传。 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/socket.h> #include <sys/epoll.h> #include <arpa/inet.h> #include <fcntl.h> #incl.
epoll实现同时承载100w客户端的数量
最新发布
weixin_46120107的博客
12-10 851
让epoll能够同时承受100w的连接，对于百万并发的业务处理，其前提条件就是要同时承受住100w的连接。
socket编程 - 何为Reactor模式
猛犸象
05-31 908
Reactor模式，是一种事件驱动机制，也叫反应器模式。应用程序需要提供相应的接口并注册到Reactor上，如果相应的事件发生，Reactor将主动调用应用程序注册的接口，这些接口又称为“回调函数”。 在Libevent中也是一样，向Libevent框架注册相应的事件和回调函数；当这些事件发生时，Libevent会调用这些回调函数处理相应的事件（I/O读写、定时和信号）。 使用Reactor模型，必备的几个组件：事件源、Reactor框架、多路复用机制和事件处理程序。 Reactor模式是一种网络编程模式，
（C++通讯架构学习笔记）：epoll介绍及原理详解
baidu_41388533的博客
11-25 7594
目录 epoll技术简介 epoll原理与函数介绍 epoll技术简介 【epoll概述】 I/O多路复用：epoll就是一种典型的I/O多路复用技术: epoll技术的最大特点是支持高并发。 传统多路复用技术select，poll，在并发量达到1000-2000，性能就会明显下降 epoll，从linux内核2.6引入的，2.6之前是没有的 epoll和kquene(freebsd)技术类似：单独一台计算机支撑少则数万，多则数十上百万并发连接的核心技术。 epoll技术完全
【Linux】Reactor模式
joy.728的博客
08-12 429
本篇博客主要讲解了什么是 Reactor 模式、Reactor 模式的组件、Reactor 模式的工作流程以及基于 Reactor 模式的 TCP 服务器等等。
epoll的优点
Moons_is_me的博客
08-09 1077
epoll既然是对select和poll的改进。在此之前，我们先看一下epoll和select和poll的调用接口上的不同，select和poll都只提供了一个函数——select或者poll函数。而epoll提供了三个函数，epoll_create,epoll_ctl和epoll_wait，epoll_create是创建一个epoll句柄；epoll_ctl是注册要监听的事件类型；epoll_w
从零构建通讯器--7.2 控制连入数，黑客--防范及畸形包应对和登录账号服务器超时踢下线
谢白羽
05-19 193
控制并发连入数量 黑客攻击的防范 超时直接提出服务器的需求 （1）控制并发连入数量 （2）黑客攻击的防范 （2.1）flood攻击防范 （2.2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值