• Java NIO系列教程(七) selector原理 Epoll版的Selector


    目录:

    Reactor(反应堆)和Proactor(前摄器)

    I/O模型之三:两种高性能 I/O 设计模式 Reactor 和 Proactor

    【转】第8章 前摄器(Proactor):用于为异步事件多路分离和分派处理器的对象行为模式

    Java NIO系列教程(八)JDK AIO编程》-- java AIO的proactor模式

    Java NIO系列教程(七) selector原理 Epoll版的Selector》--java NIO的Reactor模式

    Netty中的三种Reactor(反应堆)》 

    jdk/src/solaris/classes/sun/nio/ch/DefaultSelectorProvider.java

        public static SelectorProvider create() {
            String osname = AccessController
                .doPrivileged(new GetPropertyAction("os.name"));
            if (osname.equals("SunOS"))
                return createProvider("sun.nio.ch.DevPollSelectorProvider");
            if (osname.equals("Linux"))
                return createProvider("sun.nio.ch.EPollSelectorProvider");
            return new sun.nio.ch.PollSelectorProvider();
        }
    

    可以看到,如果osname是Linux的话,实际上真正创建的是EPollSelectorProvider。因为在Java NIO(5): IO多路复用,这篇文章里我先介绍的是poll,所以我就把EpollSelectorProvider给绕开了。今天补一下这部分的内容。

    我们继续看jdk/src/solaris/classes/sun/nio/ch/EPollSelectorProvider.java里的打开selector的定义:

        public AbstractSelector openSelector() throws IOException {
            return new EPollSelectorImpl(this);
        }
    

    OK,再去看EPollSelectorImpl的实现,这里面和昨天讲的PollSelectorImpl的实现十分相似,我就不再贴代码了。自己一定要打开源文件自己去看,我这里只是带着你浏览源码,充当向导,真正去学习去领悟还是要靠自己动手。

        EPollSelectorImpl(SelectorProvider sp) throws IOException {
           // 其他代码略,这里最重要的是初始化pollWrapper 
           try {
                pollWrapper = new EPollArrayWrapper();
                pollWrapper.initInterrupt(fd0, fd1);
                fdToKey = new HashMap<>();
            } catch (Throwable t) {
                /* ... */
            }
        }
    

    EpollSelectorImpl里最重要的方法是doSelect,这个方法与我们上节课所讲的方法大致相同,所以我就跳过这一步了,直接看pollWrapper.poll的实现。

        int poll(long timeout) throws IOException {
            updateRegistrations();
            updated = epollWait(pollArrayAddress, NUM_EPOLLEVENTS, timeout, epfd);
            for (int i=0; i<updated; i++) {
                if (getDescriptor(i) == incomingInterruptFD) {
                    interruptedIndex = i;
                    interrupted = true;
                    break; 
                }
            }
            return updated;
        }
    

    而epollWait又是一个native方法,OK,我们去看它的实现。代码位于

    jdk/src/solaris/native/sun/nio/ch/EPollArrayWrapper.c

    JNIEXPORT jint JNICALL
    Java_sun_nio_ch_EPollArrayWrapper_epollWait(JNIEnv *env, jobject this,
                                                jlong address, jint numfds,
                                                jlong timeout, jint epfd)
    {
        struct epoll_event *events = jlong_to_ptr(address);
        int res;
    
        if (timeout <= 0) {           /* Indefinite or no wait */
            RESTARTABLE(epoll_wait(epfd, events, numfds, timeout), res);
        } else {                      /* Bounded wait; bounded restarts */
            res = iepoll(epfd, events, numfds, timeout);
        }
    
        if (res < 0) {
            JNU_ThrowIOExceptionWithLastError(env, "epoll_wait failed");
        }
        return res;
    }
    

    这里出现了一个新的东西:epoll,看JDK代码就先到这里。我来讲一下epoll是什么东西。

    使用EPoll

    上节课介绍的poll方法有一个非常大的缺陷。poll 函数的返回值是一个整数,得到了这个返回值以后,我们还是要逐个去检查,比如说,有一万个socket同时poll,返回值是3,我们还是只能去遍历这一万个socket,看看它们是否有IO动作。这就很低效了,于是,就有了epoll的改进,epoll可以直接通过“输出参数”(可以理解为C语言中的指针类型的参数),一个 epoll_event 数组,直接获得这三个socket,这就比较快了。

    来具体讲一下,epoll的接口包括三个函数:

    1. int epoll_create(int size);
    创建一个epoll的句柄,size用来告诉内核这个监听的数目一共有多大。需要注意的是,当创建好epoll句柄后,它就是会占用一个fd值,在linux下如果查看/proc/进程id/fd/,是能够看到这个fd的,所以在使用完epoll后,必须调用close()关闭,否则可能导致fd被耗尽。

    2. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

    epoll的事件注册函数。

    第一个参数是epoll_create()的返回值,

    第二个参数表示动作,用三个宏来表示:
    EPOLL_CTL_ADD:注册新的fd到epfd中;
    EPOLL_CTL_MOD:修改已经注册的fd的监听事件;
    EPOLL_CTL_DEL:从epfd中删除一个fd;


    第三个参数是需要监听的fd,就是我们的socket

    第四个参数是告诉内核需要监听什么事,struct epoll_event结构如下:

    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 */
    };
    


    events可以是以下几个宏的集合:(这是最常见的三种,其他很少用到,我就先不贴了)
    EPOLLIN :表示对应的文件描述符可以读(包括对端SOCKET正常关闭);
    EPOLLOUT:表示对应的文件描述符可以写;
    EPOLLERR:表示对应的文件描述符发生错误;

    3. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
    等待事件的产生。参数events用来从内核得到事件的集合,maxevents告之内核这个events有多大,这个 maxevents的值不能大于创建epoll_create()时的size,参数timeout是超时时间(毫秒,0会立即返回,-1是永久阻塞)。该函数返回需要处理的事件数目,如返回0表示已超时。

    相比起poll,其实就多了一个 epdf 的结构和 epoll_ctl 而已。其他的主要逻辑都是一样的,所以 poll 的服务端例子,可以这样改写:

    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <arpa/inet.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <assert.h>
    #include <stdio.h>
    #include <string.h>
    #include <errno.h>
    #include <sys/epoll.h>
    
    #define MAX_FD_NUM 1024  
    #define MAXLEN 1024  
    
    int buf_len = 0;
    
    int main(int argc,char* argv[])
    {
        int i = 0;
        printf("server start up
    ");
    
        if(argc <= 2)
        {
            printf("usage:%s ip port
    ",basename(argv[0]));
            return 1;
        }
    
        const char* ip = argv[1];
        int port = atoi(argv[2]);
    
        int server_sockfd = socket(PF_INET,SOCK_STREAM,0);
    
        struct sockaddr_in server_addr;
        bzero(&server_addr, sizeof(server_addr));
        server_addr.sin_family = AF_INET;
        inet_pton(AF_INET, ip, &server_addr.sin_addr);
        server_addr.sin_port = htons(port);
    
        int ret = bind(server_sockfd, (struct sockaddr*)&server_addr, sizeof(server_addr));
        assert(ret != -1);
    
        ret = listen(server_sockfd, MAX_FD_NUM - 1);
        assert(ret != -1);
    
        struct sockaddr_in client_addr;
        socklen_t client_addr_len = sizeof(struct sockaddr_in);
    
        // 创建一个 epfd,并且把 server_sockfd 注册到这个 epfd上。
        int epfd = epoll_create(1024);
        struct epoll_event ev,events[20];
        ev.data.fd = server_sockfd;
        ev.events = EPOLLIN;
        epoll_ctl(epfd, EPOLL_CTL_ADD, server_sockfd, &ev);
    
        int cur_fd_num = 1;
        char buf[MAXLEN]={0};
    
        while (1) {
            // nReady 就是 events 数组的长度。
            int nready = epoll_wait(epfd, events, 20, 50);
    
            int i = 0;
            for (; i < nready; i++) {
                if (events[i].data.fd == server_sockfd) {
                    int client_sockfd = accept(server_sockfd,(struct sockaddr*)&client_addr,&client_addr_len);
    
                    if(client_sockfd < 0) {
                        perror("accept");
                    }
                    else {
                        printf("accept client_addr %s
    ",inet_ntoa(client_addr.sin_addr));
                        ev.data.fd = client_sockfd;
                        ev.events=EPOLLIN;
                        epoll_ctl(epfd, EPOLL_CTL_ADD, client_sockfd, &ev);
                    }
                }
                else if (events[i].events & EPOLLIN) {
                    int connfd = events[i].data.fd;
                    int n = recv(connfd, buf, MAXLEN, 0);
                    if(n < 0) {
                        if(ECONNRESET == errno) {
                            close(connfd);
                            epoll_ctl(epfd, EPOLL_CTL_DEL, connfd, 0);
                        }
                        else {
                            perror("recv");
                        }
                    }
    
                    printf("receive %s", buf);
                    buf_len = n;
    
                    ev.data.fd = connfd;
                    ev.events = EPOLLOUT;
                    epoll_ctl(epfd, EPOLL_CTL_MOD, connfd, &ev);
                }
                else if (events[i].events & EPOLLOUT) {
                    int connfd = events[i].data.fd;
                    write(connfd, buf, buf_len);
    
                    ev.data.fd = connfd;
                    ev.events = EPOLLIN;
                    epoll_ctl(epfd, EPOLL_CTL_MOD, connfd, &ev);
                }
            }
        }
    
        return 0;
    }
    

    OK,我们这个服务端的逻辑与之前poll的,或者是Java的 Selector 的例子是完全等价的。好了,今天关于Epoll就讲解这么多了。

    习题:

    EpollArrayWrapper.java还有很多点,我没有涉及,例如,pollArray和pollArrayAddress是怎么回事,epollCtl 和 epollCreate 都是在什么时候调用的,这些问题,自己去看看代码,搞清楚。

  • 相关阅读:
    Poj(1459),最大流,EK算法
    Poj(3259),SPFA,判负环
    HDU(3790),最短路二级标准
    Poj(2349),最小生成树的变形
    CSUFT2016训练赛
    NYOJ(21),BFS,三个水杯
    Poj(3687),拓扑排序,
    Poj(2367),拓扑排序
    HDU(1856),裸的带权并查集
    HDU(1572),最短路,DFS
  • 原文地址:https://www.cnblogs.com/duanxz/p/6782792.html
Copyright © 2020-2023  润新知