深度解析Java NIO底层实现原理（selector创建流程）

清疚 2022-10-11 12:21 235阅读 0赞

> 原创不易，转载请注明出处

### 文章目录 ###

*   *   *  前言
         *  Selector\#open()流程
         *   *  1.makePipe源码剖析
             *  2.EPollArrayWrapper实例化剖析
             *  3.EPollArrayWrapper初始化Interrupt解析
         *  总结

--------------------

### 前言 ###

在《[深度解析Java NIO底层实现原理（初探服务器端程序）][Java NIO]》一文中我们基于java nio写了一个服务端的程序，并深度剖析了ServerSocketChannel open与bind实现原理，本文接着那个nio程序往下剖析，看看Selector.open是怎样创建一个selector的。

### Selector\#open()流程 ###

public static Selector open() throws IOException { 
            return SelectorProvider.provider().openSelector();
    }

可以看到，先是获取provider，然后调用provider的openSelector方法来打开一个selector。  
这个的创建provider我们在《[深度解析Java NIO底层实现原理（初探服务器端程序）][Java NIO]》一文中解析的很详细，这里就不赘述，这里就是EPollSelectorProvider

public class EPollSelectorProvider
        extends SelectorProviderImpl
    { 
        public AbstractSelector openSelector() throws IOException { 
            return new EPollSelectorImpl(this);
        }
    
        public Channel inheritedChannel() throws IOException { 
            return InheritedChannel.getChannel();
        }
    }

可以看到创建了一个EPollSelectorImpl对象，看下构造方法

EPollSelectorImpl(SelectorProvider sp) throws IOException { 
        super(sp);
        long pipeFds = IOUtil.makePipe(false);
        fd0 = (int) (pipeFds >>> 32);
        fd1 = (int) pipeFds;
        pollWrapper = new EPollArrayWrapper();
        pollWrapper.initInterrupt(fd0, fd1);
        fdToKey = new HashMap<>();
    }

首先创建一个pipe管道，返回读写文件描述符，高32位是管道读端fd，低32位管道写端fd  
然后创建EPollArrayWrapper对象，初始化中断的一些东西，  
最后就是创建一个hashMap `Map<Integer,SelectionKeyImpl> fdToKey`存储的是文件描述符与事件的映射关系  
接下来我们主要看下，pipe是怎样创建的与EPollArrayWrapper创建流程。

#### 1.makePipe源码剖析 ####

long pipeFds = IOUtil.makePipe(false);

static native long makePipe(boolean blocking);

可以看到是个native方法。

找到IOUtil.c文件的makePipe方法。

JNIEXPORT jlong JNICALL
    Java_sun_nio_ch_IOUtil_makePipe(JNIEnv *env, jobject this, jboolean blocking)
    { 
        int fd[2];
    	// 调用pipe函数，创建管道
        if (pipe(fd) < 0) { 
            JNU_ThrowIOExceptionWithLastError(env, "Pipe failed");
            return 0;
        }
        if (blocking == JNI_FALSE) { 
            if ((configureBlocking(fd[0], JNI_FALSE) < 0)
                || (configureBlocking(fd[1], JNI_FALSE) < 0)) { 
                JNU_ThrowIOExceptionWithLastError(env, "Configure blocking failed");
                close(fd[0]);
                close(fd[1]);
                return 0;
            }
        }
        return ((jlong) fd[0] << 32) | (jlong) fd[1];
    }

调用c函数pipe创建管道，然后会将读端的fd写到fd数组的0位置处，将写端的fd写到数组的1位置处。  
根据是否blocking设置是否堵塞，它这里是fasle，也就是设置不阻塞。  
最后它返回一个long类型，高32 存储的读端的fd，低32 存储的写端的fd。  
对于pipe函数不了解的同学可以搜下相关资料看下。

#### 2.EPollArrayWrapper实例化剖析 ####

EPollArrayWrapper这个类其实就是对linux epoll 操作的封装。接着看下EPollArrayWrapper构造

EPollArrayWrapper() throws IOException { 
        // creates the epoll file descriptor
        //创建一个epoll描述符
        epfd = epollCreate();
        //计算需要申请内存大小 epoll事件数量* epoll_event占内存大小
        // the epoll_event array passed to epoll_wait
        int allocationSize = NUM_EPOLLEVENTS * SIZE_EPOLLEVENT;
        // 这里就是申请内存，用来存放select到的事件
        pollArray = new AllocatedNativeObject(allocationSize, true);
        // 获取这个数组的地址
        pollArrayAddress = pollArray.address();
        // eventHigh needed when using file descriptors > 64k
        if (OPEN_MAX > MAX_UPDATE_ARRAY_SIZE)
            eventsHigh = new HashMap<>();
    }

首先调用epollCreate方法创建epoll描述符。

private native int epollCreate();

可以看到这个epollCreate方法是个native方法  
EPollArrayWrapper.c 文件中

JNIEXPORT jint JNICALL
    Java_sun_nio_ch_EPollArrayWrapper_epollCreate(JNIEnv *env, jobject this)
    { 
        /* * epoll_create expects a size as a hint to the kernel about how to * dimension internal structures. We can't predict the size in advance. */
        int epfd = epoll_create(256);
        if (epfd < 0) { 
           JNU_ThrowIOExceptionWithLastError(env, "epoll_create failed");
        }
        return epfd;
    }

调用c函数epoll\_create创建一个epoll，得到一个文件描述符，这里这个256不用管他，其实在linux 内核2.6以上的版本中是可以动态扩展的了。

接着构造方法往下看：  
int allocationSize = NUM\_EPOLLEVENTS \* SIZE\_EPOLLEVENT;  
计算申请内存大小 = epoll事件数量\* epoll\_event占内存大小

epoll事件数量：  
NUM\_EPOLLEVENTS = Math.min(OPEN\_MAX, 8192)  
拿OPEN\_MAX 与8192进行比较，获取小的那个，OPEN\_MAX = IOUtil.fdLimit(); 就是去linux系统中获取文件描述符最大数

epoll\_event占内存大小：  
这个epoll\_event 其实是c的一个结构体，主要就是封装epoll事件的。

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：表示对应的文件描述符可以读；  
EPOLLOUT：表示对应的文件描述符可以写；  
EPOLLPRI：表示对应的文件描述符有紧急的数可读；  
EPOLLERR：表示对应的文件描述符发生错误；  
EPOLLHUP：表示对应的文件描述符被挂断；  
EPOLLET： ET的epoll工作模式；

SIZE\_EPOLLEVENT = sizeofEPollEvent();  
其实就是看看这个结构体占多少个字节（12字节）

JNIEXPORT jint JNICALL
    Java_sun_nio_ch_EPollArrayWrapper_sizeofEPollEvent(JNIEnv* env, jclass this)
    { 
        return sizeof(struct epoll_event);
    }

接着就是申请内存了，然后将内存地址赋值给pollArrayAddress  
如果文件描述符数量大于65535，就创建一个map，然后使用map存储。  
到这里EPollArrayWrapper实例化就完事了。

#### 3.EPollArrayWrapper初始化Interrupt解析 ####

pollWrapper.initInterrupt(fd0, fd1);

void initInterrupt(int fd0, int fd1) { 
        outgoingInterruptFD = fd1;
        incomingInterruptFD = fd0;
        epollCtl(epfd, EPOLL_CTL_ADD, fd0, EPOLLIN);
    }

调用epollCtl 方法向epoll添加 管道读端 read事件。

private native void epollCtl(int epfd, int opcode, int fd, int events);  
epollCtl是native方法，找到EPollArrayWrapper.c 对应的方法

JNIEXPORT void JNICALL
    Java_sun_nio_ch_EPollArrayWrapper_epollCtl(JNIEnv *env, jobject this, jint epfd,
                                               jint opcode, jint fd, jint events)
    { 
        struct epoll_event event;
        int res;
    
        event.events = events;
        event.data.fd = f
    
        RESTARTABLE(epoll_ctl(epfd, (int)opcode, (int)fd, &event), res);
    
        /* * A channel may be registered with several Selectors. When each Selector * is polled a EPOLL_CTL_DEL op will be inserted into its pending update * list to remove the file descriptor from epoll. The "last" Selector will * close the file descriptor which automatically unregisters it from each * epoll descriptor. To avoid costly synchronization between Selectors we * allow pending updates to be processed, ignoring errors. The errors are * harmless as the last update for the file descriptor is guaranteed to * be EPOLL_CTL_DEL. */
        if (res < 0 && errno != EBADF && errno != ENOENT && errno != EPERM) { 
            JNU_ThrowIOExceptionWithLastError(env, "epoll_ctl failed");
        }
    }

组装epoll\_event 结构体数据，可以看到，将fd存到了data的fd里面。调用epoll\_ctl注册管道读事件，让epoll关注管道读端的read事件。

参数介绍：

1.  epfd： 要操作的内核事件表的文件描述符，即 epoll\_create 的返回值
2.  opCode：指定操作类型，操作类型有三种：  
    \-> EPOLL\_CTL\_ADD：往内核事件表中注册指定fd 相关的事件  
    \-> EPOLL\_CTL\_MOD：修改指定 fd 上的注册事件  
    \-> EPOLL\_CTL\_DEL：删除指定 fd 的注册事件
3.  fd：所要操作的文件描述符，也就是要内核事件表中监听的 fd
4.  event：指定所要监听的事件类型，epoll\_event 结构指针类型。

### 总结 ###

本文主要解析了selector的初始化过程，可以看到，它先创建一个pipe管道，然后创建EPollArrayWrapper对象，我们上面也说过，这个EPollArrayWrapper封装关于linux epoll的操作， 在EPollArrayWrapper实例化的时候，调用c函数epoll\_create创建ep描述符，申请内存存放epoll事件，最后在初始化了一下Interrupt，其实就是将管道的读端的read 事件注册到epoll中，让epoll对read事件感兴趣。

[Java NIO]: https://inetyoung.blog.csdn.net/article/details/118197655