2.2.1使用epoll及reactor实现服务器百万并发

前言

本文章承接上一篇文章2.1.1网络io与select,poll,epoll,使用epoll以及reactor实现服务器百万并发。

为什么需要实现一个sock_item?

  • 每个fd都对应一个sock_item
  • sock_item包含rbuffer, wbuffer, rlength, wlength, events, callback,可使每个fd拥有独立的缓冲区

内存分配

calloc()在动态分配完内存后,自动初始化该内存空间为零,而malloc()不初始化,里边数据是随机的垃圾数据。因此使用malloc()后需要调用memset()进行初始化而使用calloc()则不需要。

百万并发尝试1

#include 
#include 
#include 
#include 
#include   // struct sockaddr_in
#include 
#include       // close()函数
#include       // memcpy()函数
#include 

#define NONBLOCK 0
#define BUFFER_LENGTH 128
#define EVENTS_LENGTH 128

// listenfd, clientfd
struct sock_item  // conn_item
{
    int fd; // clientfd

    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 reactor
{
    int epfd;  // epoll

    struct sock_item* items;
};


int main()
{
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    // 第一个参数domain为协议簇
    // (AF_UNIX:本机通信;AF_INET:TCP/IP-IPv4;AF_INET6:TCP/IP-IPv6)
    // 第二个参数type为套接字类型常用类型有:
    // (SOCK_STREAM:TCP流;SOCK_DGRAM:UDP数据报;SOCK_RAW:原始套接字)
    // 第三个参数protocol,一般设置为0
    // (
    //  当套接字使用的协议簇和类型确定时,该参数值为0;
    //  有时创建原始套接字时,不知道要使用的协议簇和类型的情况下,protocol参数可确定协议的种类
    // )
    // socket函数成功返回int类型的值,从3开始,依次递增(0对应stdin,1对应stdout,2对应stderr)
    // 失败返回"-1",错误代码写入"errno"中
    if(listenfd == -1) return -1;

    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    // INADDR_ANY 为 0.0.0.0
    // 127.0.0.1      用于本机通信(回环地址)
    // 192.168.0.123  特定对外通信
    // 0.0.0.0        任意都可通信(包括本机及对外)

    // htonl (host to net long)
    // 将long类型变量从主机字节顺序转变成网络字节顺序
    // 网络字节顺序是TCP/IP中规定好的一种数据表示格式,它与具体的CPU类型、操作系统等无关,
    // 从而可以保证数据在不同主机之间传输时能够被正确解释,
    // 网络字节顺序采用big-endian(大端)排序方式。
    servaddr.sin_port = htons(9999);
    // htons (host to net short)

    if (bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
    {
        return -2;
    }

#if NONBLOCK
    int flag = fcntl(listenfd, F_GETFL, 0);  // 获取listenfd的flag(F_GETFL:get flag)
    flag |= O_NONBLOCK;                      // 使用位或操作设置flag为非阻塞的
    fcntl(listenfd, F_SETFL, flag);          // 设置listenfd的flag(F_SETFL:set flag)
#endif
    
    listen(listenfd, 10);

    struct reactor* r = (struct reactor*)calloc(1, sizeof(struct reactor));
    if(r == NULL) return -3;

    r->items = (struct sock_item*)calloc(EVENTS_LENGTH, sizeof(struct sock_item));
    if(r->items == NULL) return -4;

    r->epfd = epoll_create(1);  // r->epfd值为4
    // 新建一个epoll描述符
    // size参数只需为大于0的数,该参数为历史遗留,现在没有意义

    struct epoll_event ev, events[EVENTS_LENGTH];
    ev.events = EPOLLIN;
    ev.data.fd = listenfd;

    epoll_ctl(r->epfd, EPOLL_CTL_ADD, listenfd, &ev);
    // 对epoll描述符进行操作(添加或者删除所有待监控的连接等)
    // 第一个参数为epfd:epoll描述符
    // 第二个参数为op:  指定操作类型
    // (
    //  EPOLL_CTL_ADD 往事件表中注册fd上的事件
    //  EPOLL_CTL_DEL 删除fd上的注册事件
    //  EPOLL_CTL_MOD 修改fd上的注册事件
    // )
    // 第三个参数为fd:   要操作的文件描述符
    // 第四个参数为event:指定事件,它是epoll_event结构指针类型
    // (
    //  epoll_event定义:
    //  events:描述事件类型,和poll支持的事件类型基本相同(两个额外的事件:EPOLLET和EPOLLONESHOT,高效运作的关键)
    //  data成员:存储用户数据
    // )

    while(1)
    {
        int nready = epoll_wait(r->epfd, events, EVENTS_LENGTH, -1);
        // 第一个参数为epfd:epoll描述符
        // 第二个参数events:   检测到事件,将所有就绪的事件从内核事件表中复制到它的第二个参数events指向的数组中
        // 第三个参数maxevents:指定最多监听多少个事件
        // 第四个参数timeout:  指定epoll的超时时间,单位是毫秒
        // (当timeout为-1是,epoll_wait调用将永远阻塞,直到某个事件发生。当timeout为0时,epoll_wait调用将立即返回)
        // 返回值:成功时返回就绪的文件描述符的个数,失败时返回-1并设置errno
        printf("---------- %d\n", nready);
        
        int i = 0;
        for(i = 0;i < nready;i++)
        {
            int clientfd = events[i].data.fd;
            if(clientfd == listenfd)  // 若触发事件的fd为listenfd,说明有客户端连接请求,执行accpet()
            {
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int connfd = accept(listenfd, (struct sockaddr*)&client, &len);

                printf("accept: %d\n",connfd);
                ev.events = EPOLLIN;
                ev.data.fd = connfd;
                epoll_ctl(r->epfd, EPOLL_CTL_ADD, connfd, &ev);

                // 初始化connfd对应的sock_item
                r->items[connfd].fd = connfd;

                r->items[connfd].rbuffer = calloc(1, BUFFER_LENGTH);
                r->items[connfd].rlength = 0;

                r->items[connfd].wbuffer = calloc(1, BUFFER_LENGTH);
                r->items[connfd].wlength = 0;

                r->items[connfd].event = EPOLLIN; 
            }
            else if(events[i].events & EPOLLIN) // clientfd
            {
                char* rbuffer = r->items[clientfd].rbuffer;
                char* wbuffer = r->items[clientfd].wbuffer;

                int n = recv(clientfd, rbuffer, BUFFER_LENGTH, 0);
                // 默认为水平触发(LT),即一次发送的数据,若一次接收无法全部接收,会继续接收多次,直到接收完发送的数据
                // 将 ev.events 设置为 EPOLLIN | EPOLLET,可改为边沿触发(ET)
                // 边沿触发(ET):只会接收一次,若无法接收完发送的数据,剩余数据会被留在内核协议栈的缓冲区,下次接收时,从剩余数据开始接收
                // 小数据倾向于LT(水平触发),大数据倾向于ET(边沿触发)
                // 水平触发可以一次性接收所有数据,而边沿触发需要通过循环才能接收所有数据(假设不能一次接收完数据)
                if(n > 0)
                {
                    //rbuffer[n] = '\0';
                    printf("recv : %s\n", rbuffer);

                    memcpy(wbuffer, rbuffer, BUFFER_LENGTH);


                    ev.events = EPOLLOUT;
                    ev.data.fd = clientfd;
                    epoll_ctl(r->epfd, EPOLL_CTL_MOD, clientfd, &ev);
                }
                else if(n == 0)  // 客户端断开时,需要调用服务器的close()函数
                {
                    free(rbuffer);
                    free(wbuffer);

                    r->items[clientfd].fd = 0;

                    close(clientfd);
                    //events[i].data.fd = -1;
                }
            }
            else if(events[i].events & EPOLLOUT)
            // 每次send之前判断IO是否可写,在可写时进行send
            // 当send返回值小于buffer长度时,说明还有数据未发出,需要等IO可写时再次发出剩余数据
            {
                char* wbuffer = r->items[clientfd].wbuffer;

                int sent = send(clientfd, wbuffer, BUFFER_LENGTH, 0);
                printf("sent : %d\n", sent);

                ev.events = EPOLLIN;
                ev.data.fd = clientfd;
                epoll_ctl(r->epfd, EPOLL_CTL_MOD, clientfd, &ev);
            }
        }
    }
}

当前问题:

  • 无法满足百万并发的需求

解决方法:

  • 将数据结构由数组改为链表加数组,并且对reactor进行进一步的封装

2.2.1使用epoll及reactor实现服务器百万并发_第1张图片

链表:适合查找有序、有规律的数据

百万并发尝试2

修改代码如下:

#include 
#include 
#include 
#include 
#include   // struct sockaddr_in
#include 
#include       // close()函数
#include       // memcpy()函数
#include 

#define BUFFER_LENGTH 128
#define EVENTS_LENGTH 128

#define ITEM_LENGTH 1024

// listenfd, clientfd
struct sock_item  // conn_item
{
    int fd; // clientfd

    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;  // epoll
    int blkcnt;

    struct eventblock* evblk;
};

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

    struct eventblock* blk = r->evblk;

    while(blk!=NULL && blk->next!=NULL)
    {
        blk = blk->next;
    }

    struct sock_item* item = (struct sock_item*)malloc(ITEM_LENGTH * sizeof(struct sock_item));
    if(item == NULL) return -4;
    memset(item, 0, ITEM_LENGTH* sizeof(struct sock_item));  // 初始化分配的内存

    printf("-------------\n");
    struct eventblock* block = (struct eventblock*)malloc(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
    {
        blk->next = block;
    }
    ++r->blkcnt;

    return 0;
}

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

    printf("reactor_lookup --> %d\n", r->blkcnt);
    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];
}

int main()
{
    int listenfd = socket(AF_INET, SOCK_STREAM, 0);
    // 第一个参数domain为协议簇
    // (AF_UNIX:本机通信;AF_INET:TCP/IP-IPv4;AF_INET6:TCP/IP-IPv6)
    // 第二个参数type为套接字类型常用类型有:
    // (SOCK_STREAM:TCP流;SOCK_DGRAM:UDP数据报;SOCK_RAW:原始套接字)
    // 第三个参数protocol,一般设置为0
    // (
    //  当套接字使用的协议簇和类型确定时,该参数值为0;
    //  有时创建原始套接字时,不知道要使用的协议簇和类型的情况下,protocol参数可确定协议的种类
    // )
    // socket函数成功返回int类型的值,从3开始,依次递增(0对应stdin,1对应stdout,2对应stderr)
    // 失败返回"-1",错误代码写入"errno"中
    if(listenfd == -1) return -1;

    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    // INADDR_ANY 为 0.0.0.0
    // 127.0.0.1      用于本机通信(回环地址)
    // 192.168.0.123  特定对外通信
    // 0.0.0.0        任意都可通信(包括本机及对外)

    // htonl (host to net long)
    // 将long类型变量从主机字节顺序转变成网络字节顺序
    // 网络字节顺序是TCP/IP中规定好的一种数据表示格式,它与具体的CPU类型、操作系统等无关,
    // 从而可以保证数据在不同主机之间传输时能够被正确解释,
    // 网络字节顺序采用big-endian(大端)排序方式。
    servaddr.sin_port = htons(9999);
    // htons (host to net short)

    if (bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
    {
        return -2;
    }
    
    listen(listenfd, 10);

    struct reactor* r = (struct reactor*)calloc(1, sizeof(struct reactor));
    if(r == NULL)
    {
        return -3;
    }

    r->epfd = epoll_create(1);  // r->epfd值为4
    // 新建一个epoll描述符
    // size参数只需为大于0的数,该参数为历史遗留,现在没有意义

    struct epoll_event ev, events[EVENTS_LENGTH];
    ev.events = EPOLLIN;
    ev.data.fd = listenfd;

    epoll_ctl(r->epfd, EPOLL_CTL_ADD, listenfd, &ev);
    // 对epoll描述符进行操作(添加或者删除所有待监控的连接等)
    // 第一个参数为epfd:epoll描述符
    // 第二个参数为op:  指定操作类型
    // (
    //  EPOLL_CTL_ADD 往事件表中注册fd上的事件
    //  EPOLL_CTL_DEL 删除fd上的注册事件
    //  EPOLL_CTL_MOD 修改fd上的注册事件
    // )
    // 第三个参数为fd:   要操作的文件描述符
    // 第四个参数为event:指定事件,它是epoll_event结构指针类型
    // (
    //  epoll_event定义:
    //  events:描述事件类型,和poll支持的事件类型基本相同(两个额外的事件:EPOLLET和EPOLLONESHOT,高效运作的关键)
    //  data成员:存储用户数据
    // )

    while(1)
    {
        int nready = epoll_wait(r->epfd, events, EVENTS_LENGTH, -1);
        // 第一个参数为epfd:epoll描述符
        // 第二个参数events:   检测到事件,将所有就绪的事件从内核事件表中复制到它的第二个参数events指向的数组中
        // 第三个参数maxevents:指定最多监听多少个事件
        // 第四个参数timeout:  指定epoll的超时时间,单位是毫秒
        // (当timeout为-1是,epoll_wait调用将永远阻塞,直到某个事件发生。当timeout为0时,epoll_wait调用将立即返回)
        // 返回值:成功时返回就绪的文件描述符的个数,失败时返回-1并设置errno
        printf("---------- %d\n", nready);
        
        int i = 0;
        for(i = 0;i < nready;i++)
        {
            int clientfd = events[i].data.fd;
            if(clientfd == listenfd)  // 若触发事件的fd为listenfd,说明有客户端连接请求,执行accpet()
            {
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int connfd = accept(listenfd, (struct sockaddr*)&client, &len);

                printf("accept: %d\n",connfd);
                ev.events = EPOLLIN;
                ev.data.fd = connfd;
                epoll_ctl(r->epfd, EPOLL_CTL_ADD, connfd, &ev);
				
                // 使用reactor_lookup()函数查找fd对应的sock_item,并对其进行初始化
                struct sock_item* item = reactor_lookup(r, connfd);
                item->fd = connfd;
                item->rbuffer = calloc(1, BUFFER_LENGTH);
                item->rlength = 0;

                item->wbuffer = calloc(1, BUFFER_LENGTH);
                item->wlength = 0;
            }
            else if(events[i].events & EPOLLIN) // clientfd
            {
                struct sock_item* item = reactor_lookup(r, clientfd);

                char* rbuffer = item->rbuffer;
                char* wbuffer = item->wbuffer;

                int n = recv(clientfd, rbuffer, BUFFER_LENGTH, 0);
                // 默认为水平触发(LT),即一次发送的数据,若一次接收无法全部接收,会继续接收多次,直到接收完发送的数据
                // 将 ev.events 设置为 EPOLLIN | EPOLLET,可改为边沿触发(ET)
                // 边沿触发(ET):只会接收一次,若无法接收完发送的数据,剩余数据会被留在内核协议栈的缓冲区,下次接收时,从剩余数据开始接收
                // 小数据倾向于LT(水平触发),大数据倾向于ET(边沿触发)
                // 水平触发可以一次性接收所有数据,而边沿触发需要通过循环才能接收所有数据(假设不能一次接收完数据)
                if(n > 0)
                {
                    //rbuffer[n] = '\0';
                    printf("recv : %s\n", rbuffer);

                    memcpy(wbuffer, rbuffer, BUFFER_LENGTH);


                    ev.events = EPOLLOUT;
                    ev.data.fd = clientfd;
                    epoll_ctl(r->epfd, EPOLL_CTL_MOD, clientfd, &ev);
                }
                else if(n == 0)  // 客户端断开时,需要调用服务器的close()函数
                {
                    free(rbuffer);
                    free(wbuffer);

                    item->fd = 0;

                    close(clientfd);
                    //events[i].data.fd = -1;
                }
            }
            else if(events[i].events & EPOLLOUT)
            // 每次send之前判断IO是否可写,在可写时进行send
            // 当send返回值小于buffer长度时,说明还有数据未发出,需要等IO可写时再次发出剩余数据
            {
                struct sock_item* item = reactor_lookup(r, clientfd);

                char* wbuffer = item->wbuffer;

                int sent = send(clientfd, wbuffer, BUFFER_LENGTH, 0);
                printf("sent : %d\n", sent);

                ev.events = EPOLLIN;
                ev.data.fd = clientfd;
                epoll_ctl(r->epfd, EPOLL_CTL_MOD, clientfd, &ev);
            }
        }
    }
}

我们使用send和recv对fd进行操作,操作的底层为五元组(sip,sport,dip,dport,proto)即(源ip,源端口,目的ip,目的端口,协议),五元组确定一个唯一的连接。

为了达到百万连接,源端口不够的解决方法(对客户端而言):

  • 增加源ip(增加网卡,绑定不同ip地址,使用多进程)
  • 增加目的ip
  • 增加目的端口

其中客户端的源端口范围为0-65535,最大值为固定值,不可改变。

这里采用增加目的端口的方案,即增加服务器端口。

百万并发尝试3

修改代码如下:

#include 
#include 
#include 
#include 
#include   // struct sockaddr_in
#include 
#include       // close()函数
#include       // memcpy()函数
#include 

#define BUFFER_LENGTH 128
#define EVENTS_LENGTH 128

#define PORT_COUNT  100
#define ITEM_LENGTH 1024

// listenfd, clientfd
struct sock_item  // conn_item
{
    int fd; // clientfd

    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;  // 数组,含ITEM_LENGTH个sock_item
    struct eventblock* next;
};

struct reactor
{
    int epfd;  // epoll
    int blkcnt;

    struct eventblock* evblk;  // 链表
};

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

    struct eventblock* blk = r->evblk;

    while(blk!=NULL && blk->next!=NULL)
    {
        blk = blk->next;
    }

    struct sock_item* items = (struct sock_item*)malloc(ITEM_LENGTH * sizeof(struct sock_item));
    if(items == NULL) return -4;
    memset(items, 0, ITEM_LENGTH * sizeof(struct sock_item));  // 初始化分配的内存

    //printf("-------------\n");
    struct eventblock* block = (struct eventblock*)malloc(sizeof(struct eventblock));
    if(block == NULL)
    {
        free(items);
        return -5;
    }
    memset(block, 0, sizeof(struct eventblock));

    block->items = items;
    block->next = NULL;

    if(blk == NULL)
    {
        r->evblk = block;
    }
    else
    {
        blk->next = block;
    }
    ++r->blkcnt;

    return 0;
}

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

    //printf("reactor_lookup --> %d\n", r->blkcnt);
    int blkidx = sockfd / ITEM_LENGTH;
    while(blkidx >= r->blkcnt)  // 因为sockfd不可能突增,所以该循环只执行一次,也可使用if
    {
        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 = socket(AF_INET, SOCK_STREAM, 0);
    // 第一个参数domain为协议簇
    // (AF_UNIX:本机通信;AF_INET:TCP/IP-IPv4;AF_INET6:TCP/IP-IPv6)
    // 第二个参数type为套接字类型常用类型有:
    // (SOCK_STREAM:TCP流;SOCK_DGRAM:UDP数据报;SOCK_RAW:原始套接字)
    // 第三个参数protocol,一般设置为0
    // (
    //  当套接字使用的协议簇和类型确定时,该参数值为0;
    //  有时创建原始套接字时,不知道要使用的协议簇和类型的情况下,protocol参数可确定协议的种类
    // )
    // socket函数成功返回int类型的值,从3开始,依次递增(0对应stdin,1对应stdout,2对应stderr)
    // 失败返回"-1",错误代码写入"errno"中
    if(listenfd == -1) return -1;

    struct sockaddr_in servaddr;
    servaddr.sin_family = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    // INADDR_ANY 为 0.0.0.0
    // 127.0.0.1      用于本机通信(回环地址)
    // 192.168.0.123  特定对外通信
    // 0.0.0.0        任意都可通信(包括本机及对外)

    // htonl (host to net long)
    // 将long类型变量从主机字节顺序转变成网络字节顺序
    // 网络字节顺序是TCP/IP中规定好的一种数据表示格式,它与具体的CPU类型、操作系统等无关,
    // 从而可以保证数据在不同主机之间传输时能够被正确解释,
    // 网络字节顺序采用big-endian(大端)排序方式。
    servaddr.sin_port = htons(port);
    // htons (host to net short)

    if (bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr)) == -1)
    // 绑定本地的ip和端口,还有协议
    {
        return -2;
    }
    
    listen(listenfd, 10);

    return listenfd;
}

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

int main()
{
    struct reactor* r = (struct reactor*)calloc(1, sizeof(struct reactor));
    if(r == NULL)
    {
        return -3;
    }

    r->epfd = epoll_create(1);  // r->epfd值为4
    // 新建一个epoll描述符
    // size参数只需为大于0的数,该参数为历史遗留,现在没有意义
    struct epoll_event ev, events[EVENTS_LENGTH];

    int sockfds[PORT_COUNT] = {0};
    int i = 0;
    // 创建多个listenfd,增加服务器端口
    for(i=0;i<PORT_COUNT;i++)
    {
        sockfds[i] = init_server(9999+i);

        ev.events = EPOLLIN;
        ev.data.fd = sockfds[i];

        epoll_ctl(r->epfd, EPOLL_CTL_ADD, sockfds[i], &ev);
        // 对epoll描述符进行操作(添加或者删除所有待监控的连接等)
        // 第一个参数为epfd:epoll描述符
        // 第二个参数为op:  指定操作类型
        // (
        //  EPOLL_CTL_ADD 往事件表中注册fd上的事件
        //  EPOLL_CTL_DEL 删除fd上的注册事件
        //  EPOLL_CTL_MOD 修改fd上的注册事件
        // )
        // 第三个参数为fd:   要操作的文件描述符
        // 第四个参数为event:指定事件,它是epoll_event结构指针类型
        // (
        //  epoll_event定义:
        //  events:描述事件类型,和poll支持的事件类型基本相同(两个额外的事件:EPOLLET和EPOLLONESHOT,高效运作的关键)
        //  data成员:存储用户数据
        // )
    }

    while(1)
    {
        int nready = epoll_wait(r->epfd, events, EVENTS_LENGTH, -1);
        // 第一个参数为epfd:epoll描述符
        // 第二个参数events:   检测到事件,将所有就绪的事件从内核事件表中复制到它的第二个参数events指向的数组中
        // 第三个参数maxevents:指定最多监听多少个事件
        // 第四个参数timeout:  指定epoll的超时时间,单位是毫秒
        // (当timeout为-1是,epoll_wait调用将永远阻塞,直到某个事件发生。当timeout为0时,epoll_wait调用将立即返回)
        // 返回值:成功时返回就绪的文件描述符的个数,失败时返回-1并设置errno
        //printf("---------- %d\n", nready);
        
        int i = 0;
        for(i = 0;i < nready;i++)
        {
            int clientfd = events[i].data.fd;
            if(is_listenfd(sockfds, clientfd))  // 若触发事件的fd为listenfd,说明有客户端连接请求,执行accpet()
            {
                struct sockaddr_in client;
                socklen_t len = sizeof(client);
                int connfd = accept(clientfd, (struct sockaddr*)&client, &len);

                if(connfd % 1000 == 999)
                {

                    printf("accept: %d\n",connfd);
                }
                ev.events = EPOLLIN;
                ev.data.fd = connfd;
                epoll_ctl(r->epfd, EPOLL_CTL_ADD, connfd, &ev);
				
                // 使用reactor_lookup()函数查找fd对应的sock_item,并对其进行初始化
                struct sock_item* item = reactor_lookup(r, connfd);
                item->fd = connfd;
                item->rbuffer = calloc(1, BUFFER_LENGTH);
                item->rlength = 0;

                item->wbuffer = calloc(1, BUFFER_LENGTH);
                item->wlength = 0;
            }
            else if(events[i].events & EPOLLIN) // clientfd
            {
                struct sock_item* item = reactor_lookup(r, clientfd);

                char* rbuffer = item->rbuffer;
                char* wbuffer = item->wbuffer;

                int n = recv(clientfd, rbuffer, BUFFER_LENGTH, 0);
                // 默认为水平触发(LT),即一次发送的数据,若一次接收无法全部接收,会继续接收多次,直到接收完发送的数据
                // 将 ev.events 设置为 EPOLLIN | EPOLLET,可改为边沿触发(ET)
                // 边沿触发(ET):只会接收一次,若无法接收完发送的数据,剩余数据会被留在内核协议栈的缓冲区,下次接收时,从剩余数据开始接收
                // 小数据倾向于LT(水平触发),大数据倾向于ET(边沿触发)
                // 水平触发可以一次性接收所有数据,而边沿触发需要通过循环才能接收所有数据(假设不能一次接收完数据)
                if(n > 0)
                {
                    //rbuffer[n] = '\0';
                    //printf("recv : %s\n", rbuffer);

                    memcpy(wbuffer, rbuffer, BUFFER_LENGTH);


                    ev.events = EPOLLOUT;
                    ev.data.fd = clientfd;
                    epoll_ctl(r->epfd, EPOLL_CTL_MOD, clientfd, &ev);
                }
                else if(n == 0)  // 客户端断开时,需要调用服务器的close()函数
                {
                    free(rbuffer);
                    free(wbuffer);

                    item->fd = 0;

                    close(clientfd);
                    //events[i].data.fd = -1;
                }
            }
            else if(events[i].events & EPOLLOUT)
            // 每次send之前判断IO是否可写,在可写时进行send
            // 当send返回值小于buffer长度时,说明还有数据未发出,需要等IO可写时再次发出剩余数据
            {
                struct sock_item* item = reactor_lookup(r, clientfd);

                char* wbuffer = item->wbuffer;

                int sent = send(clientfd, wbuffer, BUFFER_LENGTH, 0);
                //printf("sent : %d\n", sent);

                ev.events = EPOLLIN;
                ev.data.fd = clientfd;
                epoll_ctl(r->epfd, EPOLL_CTL_MOD, clientfd, &ev);
            }
        }
    }
}

流程:

  • 创建reactor
  • 创建epfd,赋给reactor->epfd
  • 创建PORT_COUNT个listenfd,并与PORT_COUNT个端口(从9999开始)连接
  • 将所有listenfd对应的epoll_event->events设置为EPOLLIN(即监听listenfd的输入事件)并加入epoll监听列表
  • 执行循环:
    • 使用epoll_wait返回就绪的epoll_event
    • 检测epoll_event对应的fd是否为listenfd,若是,则执行accpet()与客户端连接,并将clientfd加入epoll监听列表,调用reactor_lookup寻找clientfd,返回对应的sock_item,对sock_item进行初始化(赋值fd,分配缓冲区)
    • 若为clientfd且为输入事件,执行recv()从客户端接收数据
    • 若为clientfd且为输出事件,执行send()向客户端发送数据

通过测试,该代码可实现百万并发。

百万并发测试前注意事项:

  • 需要准备4台虚拟机,1台作为服务器(内存8G),3台作为客户端(内存2G)

  • 修改最大文件打开数,因为fd也属于文件。

    • ulimit -a          // 查看限制
      ulimit -n 1000000  // 将最大文件打开数改为1000000(临时的,重启后重置)
      
  • 修改/etc/sysctl.conf文件

    • 打开文件

      • vim /etc/sysctl.conf
        
    • 在文件最下方添加以下内容

      • net.ipv4.tcp_mem = 262144 524288 786432
        net.ipv4.tcp_wmem = 1024 1024 2048
        net.ipv4.tcp_rmem = 1024 1024 2048
        fs.file-max = 1048576
        net.ipv4.tcp_max_orphans = 16384
        net.ipv4.tcp_mem = 252144 524288 786432
        net.ipv4.tcp_wmem = 2048 2048 4096
        net.ipv4.tcp_rmem = 2048 2048 4096
        fs.file-max = 1048576
        net.nf_conntrack_max = 1048576
        net.netfilter.nf_conntrack_tcp_timeout_established = 1200
        
    • 从/etc/sysctl.conf中加载系统参数

      • sysctl -p
        modprobe nf_conntrack
        

参考博客:

ulimit命令用法详解

Linux系统中sysctl命令详解

高并发访问时,提示: Cannot assign requested address 异常,解决方法

你可能感兴趣的:(C/C++Linux服务器开发,服务器,网络,tcp/ip,linux,后端)