io多路复用(select/poll/epoll)

什么是io多路复用？为什么要有io多路复用？
原始的server，处理多个连接的方法，有两种：
1）一个while循环，不断去轮询，检测每一个socket是否有消息，并处理；
2）主线程accept，之后一个连接一个线程
上述两种方法，效率肯定不高。很多时候，都是做的无效的recv，并且线程是占用资源的，为每一个socket创建一个线程肯定是不合算的。
因此，linux内核提供了select/poll，实现了io多路复用。内核为不断轮询检测Io，然后告诉用户进程哪些io可读/可写。将检测io可读/可写的状态，与实际的recv/send进行分离。

为什么要有epoll？epoll比select/poll强在哪里？
select/poll, 调用的时候，每次都需要将关心的socket传入内核，从用户空间copy进内核；返回的时候，又将所有socket状态都返回，需要进行遍历操作。所以效率不高，出现了C10K的问题，即并发1万个连接，就到了select/poll的性能瓶颈。
select性能最优是连接数在1024(FD_SETSIZE)左右, poll与select原理一样，所以性能也差不多。
linux2.6开始，提供了epoll来解决C10K的问题。epoll使用rbtree+链表，rbtree存储待检测的socket，epoll_wait检测后，将链表(就绪队列)传入用户空间，就绪队列里面存的都是可读/可写的socket。效率比select/poll提升很多。单台server使用epoll，可以达到百万并发。

listen参数backlog的含义

int listen(int sockfd, int backlog) // backlog是TCP三次握手中，sync队列和accept队列元素之和

epoll中什么是ET?LT?
Level Triggered (LT)
socket的recv buffer不为空，有数据可读，读事件一直触发
Edge Triggered(ET)
socket的send buffer不满，可以继续写数据，写事件一直触发
大块数据用LT, 小块数据用ET。

select/poll/epoll使用，直接参考下面的代码

#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define BUFFER_LENGTH 1024
#define POLL_SIZE 1024
#define EPOLL_SIZE 1024

void* client_proc(void *arg) {
    int client_fd = *(int*)arg;

    while (1) {
        char buffer[BUFFER_LENGTH] = {0};
        int ret = recv(client_fd, buffer, BUFFER_LENGTH, 0);
        if (ret < 0) {
            if (errno == EAGAIN || errno == EWOULDBLOCK) {
                printf("data has already been read by another thread\n");
            }
            return NULL;
        } else if (ret == 0) {
            printf("disconnect \n");
            return NULL;
        } else {
            printf("Recv: %s, %d Bytes\n", buffer, ret);
        }
    }
}

int main(int argc, char* argv[]) {
    if (argc < 2) {
        printf("Parameter error\n");
        return -1;
    }
    int port = atoi(argv[1]);

    int listen_fd = socket(AF_INET, SOCK_STREAM, 0);
    if (listen_fd < 0) {
        perror("socket");
        return -1;
    }

    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(struct sockaddr_in));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = INADDR_ANY;

    if (bind(listen_fd, (struct sockaddr*)&addr, sizeof(struct sockaddr_in)) < 0) {
        perror("bind");
        return 2;
    }
    
    if (listen(listen_fd, 10)) {
        perror("listen");
        return 3;
    }

#if 1
    while (1) {
        struct sockaddr_in client_addr;
        memset(&client_addr, 0, sizeof(struct sockaddr_in));
        int client_len = sizeof(struct sockaddr_in);

        int client_fd = accept(listen_fd, (struct sockaddr *)&client_addr, &client_len);
        if (client_fd <= 0) {
            continue;
        }

        pthread_t thread_id;
        int ret = pthread_create(&thread_id, NULL, client_proc, &client_fd);
        if (ret < 0) {
            perror("pthread_create");
            exit(1);
        }
    }
#elif 1
    fd_set rset_w, rset_c;

    FD_ZERO(&rset_w);
    FD_SET(listen_fd, &rset_w);

    int max_fd = listen_fd;

    while (1) {
        rset_c = rset_w;

        int nready = select(max_fd + 1, &rset_c, NULL, NULL, NULL);
        if (nready < 0) {
            perror("select");
            continue;
        }

        if (FD_ISSET(listen_fd, &rset_c)) {
            struct sockaddr_in client_addr;
            memset(&client_addr, 0, sizeof(struct sockaddr_in));
            socklen_t client_len = sizeof(struct sockaddr_in);

            int client_fd = accept(listen_fd, (struct sockaddr*)&client_addr, &client_len);
            if (client_fd <= 0) {
                continue;
            }

            char str[INET_ADDRSTRLEN] = {0};
            printf("received from %s at port %d, listen_fd:%d, client_fd:%d\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)),
                ntohs(client_addr.sin_port), listen_fd, client_fd);
            
            if (max_fd == FD_SETSIZE) {
                printf("client_fd --> out of range\n");
                break;
            }
            FD_SET(client_fd, &rset_w);

            if (client_fd > max_fd) {
                max_fd = client_fd;
            }

            printf("listen_fd: %d, max_fd:%d, clietn_fd: %d\n", listen_fd, max_fd, client_fd);

            if (--nready == 0) {
                continue;
            }

        }

        for (int i = listen_fd + 1; i <= max_fd; i++) {
            if (FD_ISSET(i, &rset_c)) {
                char buffer[BUFFER_LENGTH] = {0};
                int ret = recv(i, buffer, BUFFER_LENGTH, 0);
                if (ret < 0) {
                    if (errno == EAGAIN || errno == EWOULDBLOCK) {
                        printf("data has alread beed read by another thread\n");
                    }
                    FD_CLR(i, &rset_w);
                    close(i);
                } else if (ret == 0) {
                    printf("disconnect %d\n", i);
                    FD_CLR(i, &rset_w);
                    close(i);
                } else {
                    printf("Recv: %s, %d Bytes\n", buffer, ret);
                }
            }
            if (--nready == 0) {
                break;
            }
        }
    }
#elif 1
    struct pollfd fds[POLL_SIZE] = {0};
    int max_fd = listen_fd;

    int i = 0;
    for (i = 0; i < POLL_SIZE; i++) {
        fds[i].fd = -1;
    }
    fds[listen_fd].fd = listen_fd;
    fds[listen_fd].events = POLLIN;

    while (1) {
        int nready = poll(fds, max_fd + 1, -1);

        if (nready < 0) {
            perror("poll");
            continue;
        }

        if ((fds[listen_fd].revents & POLLIN) == POLLIN)  {
            struct sockaddr_in client_addr;
            memset(&client_addr, 0, sizeof(struct sockaddr_in));
            socklen_t client_len = sizeof(struct sockaddr_in);

            int client_fd = accept(listen_fd, (struct sockaddr*)&client_addr, &client_len);
            if (client_fd <= 0) {
                continue;
            }

            char str[INET_ADDRSTRLEN] = {0};
            printf("received from %s at port %d, listen_fd:%d, client_fd:%d\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)),
                ntohs(client_addr.sin_port), listen_fd, client_fd);
            
            if (max_fd == POLL_SIZE) {
                printf("client_fd --> out of range\n");
                break;
            }
            fds[client_fd].fd = client_fd;
            fds[client_fd].events = POLLIN;

            if (client_fd > max_fd) {
                max_fd = client_fd;
            }

            printf("listen_fd: %d, max_fd:%d, clietn_fd: %d\n", listen_fd, max_fd, client_fd);

            if (--nready == 0) {
                continue;
            }

        }

        for (int i = listen_fd + 1; i <= max_fd; i++) {
            if (fds[i].revents & POLLIN) {
                char buffer[BUFFER_LENGTH] = {0};
                int ret = recv(i, buffer, BUFFER_LENGTH, 0);
                if (ret < 0) {
                    if (errno == EAGAIN || errno == EWOULDBLOCK) {
                        printf("data has alread beed read by another thread\n");
                    }
                    fds[i].fd = -1;
                    close(i);
                } else if (ret == 0) {
                    printf("disconnect %d\n", i);
                    fds[i].fd = -1;
                    close(i);
                } else {
                    printf("Recv: %s, %d Bytes\n", buffer, ret);
                }
            }
            if (--nready == 0) {
                break;
            }
        }
    }
#else
    int epfd = epoll_create(1);
    struct epoll_event ev, events[EPOLL_SIZE] = {0};

    ev.events = EPOLLIN;
    ev.data.fd = listen_fd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, listen_fd, &ev);

    while (1) {
        int nready = epoll_wait(epfd, events, EPOLL_SIZE, -1);
        if (nready == -1) {
            perror("epoll_wait");
            break;
        }
        int i = 0;
        for (i = 0; i < nready; i++) {
            if (events[i].data.fd == listen_fd) {
                struct sockaddr_in client_addr;
                memset(&client_addr, 0, sizeof(struct sockaddr_in));
                socklen_t client_len = sizeof(client_addr);

                int client_fd = accept(listen_fd, (struct sockaddr*)&client_addr, &client_len);
                if (client_fd <= 0) {
                    continue;
                }

                char str[INET_ADDRSTRLEN] = {0};
                printf("received from %s at port %d, listen_fd:%d, client_fd:%d\n", inet_ntop(AF_INET, &client_addr.sin_addr, str, sizeof(str)),
                    ntohs(client_addr.sin_port), listen_fd, client_fd);
                
                ev.events = EPOLLIN | EPOLLET;
                ev.data.fd = client_fd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &ev);
            } else {
                int client_fd = events[i].data.fd;

                char buffer[BUFFER_LENGTH] = {0};
                int ret = recv(client_fd, buffer, BUFFER_LENGTH, 0);
                if (ret < 0) {
                    if (errno == EAGAIN || errno == EWOULDBLOCK) {
                        printf("data has alread beed read by another thread\n");
                    }
                    close(client_fd);

                    ev.events = EPOLLIN | EPOLLET;
                    ev.data.fd = client_fd;
                    epoll_ctl(epfd, EPOLL_CTL_DEL, client_fd, &ev);
                } else if (ret == 0) {
                    printf("disconnect %d\n", client_fd);
                    close(client_fd);
                    ev.events = EPOLLIN | EPOLLET;
                    ev.data.fd = client_fd;
                    epoll_ctl(epfd, EPOLL_CTL_DEL, client_fd, &ev);
                } else {
                    printf("Recv: %s, %d Bytes\n", buffer, ret);
                }
            }
        }
    }

#endif
    return 0;
}