网络编程第三课-事件驱动-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_42419365/article/details/144212645

事件驱动及百万并发

预备知识

回调函数就是把某个函数指针作为参数传入到某个函数中，当函数内部实现了某个逻辑后，调用这个传进来的函数，就叫做回调函数。


int add(int a, int b){
    return a + b;
}
int mul(int a, int b){
    return a * b;
}

//把函数指针作为参数传进去，这是一个两个整数为参数，返回值为整数的函数
//其实可以错误的把函数指针理解为函数的别名
int choose(int a, int b, int (*callback)(int, int)){
    printf("result is %d"， callback(a, b));
}
int main(){
    int x = 3, y = 4;
    choose(x, y, add);
    choose(x, y, mul);
}

使用typedef关键字

typedef int (*callback)(int)
//把一个函数指针重新定义为了 callback；
//之后可以给这个函数指针赋予不同的函数

事件驱动-基于epoll

对于io多路复用而言，操作系统内核只是提供了管理不同io设备（即文件描述符）的方法，其实我们最终要做的并不是管理这些io设备，而是根据io设备不同的状态，提供不同的方案。这就叫做事件驱动：根据io不同的读写事件，做出不同的反馈。

其实，我的理解就是，用事件驱动的方式，实现了c++中每个对象实例中的方法。即：当满足某个条件后，就调用该实例的某个方法。所以需要在定义一个事件驱动的结构体来模拟c++中的对象，然后用回调函数来模拟对象中的方法。以下的数组其实就是构造的对象

使用event_register来模拟创建对象的功能，即调用了该函数，就在上述数组中加入一个新的数据表示新对象，并且根据对象的不同实现不同的回调函数

int event_register(int fd, int event){
    conn_list[fd].fd = fd;
    conn_list[fd].r_action.recv_callback = recv_cb;
    conn_list[fd].send_callback = sent_cb;

    memset(conn_list[fd].rbuffer, 0, BUFFER_SIZE);
    conn_list[fd].rlength = 0;

    memset(conn_list[fd].wbuffer, 0, BUFFER_SIZE);
    conn_list[fd].wlength = 0;

    set_event(fd, event, 1);
}

把不同的函数封装起来，有accept、recv、sent等，分别封装成函数，这样当达到了某个条件，就可以直接调用。

accept_cb回调函数的实现：

//accept_cb的实现
int accept_cb(int fd){
    struct sockaddr_in clientaddr;
    socklen_t len = sizeof(clientaddr);

    int clientfd = accept(fd, (struct sockaddr*)&clientaddr, &len);
    printf("%d has connected!\n", clientfd);

    //
    /*conn_list[clientfd].fd = clientfd;
    conn_list[clientfd].r_action.recv_callback = recv_cb;
    conn_list[clientfd].send_callback = sent_cb;

    memset(conn_list[clientfd].rbuffer, 0, BUFFER_SIZE);
    conn_list[clientfd].rlength = 0;

    memset(conn_list[clientfd].wbuffer, 0, BUFFER_SIZE);
    conn_list[clientfd].wlength = 0;

    set_event(clientfd, EPOLLIN);*/

    event_register(clientfd, EPOLLIN);

    return 0;
}

recv_cb函数的实现

int recv_cb(int fd){
    
    int count = recv(fd, conn_list[fd].rbuffer, BUFFER_SIZE, 0);
    if(count == 0){
        printf("%d disconnected!\n", fd);
        close(fd);
        epoll_ctl(fd, EPOLL_CTL_DEL, fd, NULL);
        return 0;
    }
    conn_list[fd].rlength = count;
    printf("receive: %s \n", conn_list[fd].rbuffer);

#if 1
    conn_list[fd].wlength = conn_list[fd].rlength;
    memcmp(conn_list[fd].wbuffer, conn_list[fd].rbuffer, conn_list[fd].wlength);
#endif

    set_event(fd, EPOLLOUT, 0);

    return count;
}

sent_cb的实现：

int sent_cb(int fd){

    int count = send(fd, conn_list[fd].wbuffer, BUFFER_SIZE, 0);

    set_event(fd, EPOLLIN, 0);

    return count;
}

所以，当创建了一个对象之后，其实需要注册两个功能。一个是创建对象的注册，即event_rigister；一个是即将传入操作系统内核epoll中的注册，即set_event。

整体流程

百万并发

用以上完成的代码实现server的百万并发,即server可以同时处理百万级别的访问

首先将上述event的数组大小设置为 1048576，即最大可以实现1048576个客户端连接

服务端：

192.168.9.13 2000~2020

线程 1

客户端

192.168.9.253

线程 1

第一个问题：

客户端出现如下问题：

客户端 ulimit -a 把openfiles改为1048576即可。

服务端出现：

在accept时出现错误，需要判断clientfd 小于0的情况

第二个问题：

客户端出现如下问题：

地址不够不够分配

对于一个tcp连接，是通过五元组（源地址，目标地址，源端口，目标端口，协议）固定的，其中源地址和目标地址是无法改变的，源端口是1024-65535是系统固定的，只能修改目标端口。

//修改目标端口
//在服务端更改，设置max_port为20，相当于扩容了20倍
for(int i = 0; i < MAX_PORT; i++){
    int servfd = init_server(port);
    
    conn_list[servfd].fd = servfd;
    conn_list[servfd].r_action.recv_callback = accept_cb;
    set_event(servfd, EPOLLIN, 1);
}

第三个问题：