Unix系统有五种IO模型分别是阻塞IO(blocking IO)，非阻塞IO( non-blocking IO)，IO多路复用(IO multiplexing)，信号驱动(SIGIO/Signal IO)和异步IO(Asynchronous IO)。而IO多路复用通常有select，poll，epoll，kqueue等方式。而多路复用器Selector，就是采用这些IO多路复用的机制获取事件。JDK中的NIO(new IO)包，采用的就是IO多路复用的模型。

select，poll和epoll

阻塞IO下，应用程序调用IO函数，如果没有数据贮备好，那么IO操作会一直阻塞下去，阻塞IO不会占用大量CPU，但在这种IO模型下，一个线程只能处理一个文件描述符的IO事件；非阻塞IO下，应用程序调用IO事件，如果数据没有准备好，会直接返回一个错误，应用程序不会阻塞，这样就可以同时处理多个文件描述符的IO事件，但是需要不间断地轮询来获取IO事件，对CPU是很大的浪费。并且阻塞IO和非阻塞IO调用一个IO函数只能获取一个IO事件。

select，poll和epoll是最常见的三种IO多路复用的方式，它们都支持同时感知多个IO事件，它们的工作特点和区别如下：

select可以在一定时间内监视多个文件描述符的IO事件，select函数需要传入要监视的文件描述符的句柄作为参数，并且返回所有文件描述符，应用程序需要遍历所有的循环来看每一个文件描述符是否有IO事件发生，效率较低。并且，select默认只能监视1024个文件描述符，这些文件描述符采用数组进行存储，可以修改FD_SETSIZE的值来修改文件描述符的数量限制。

poll和select类似，poll采用链表存储监视的文件描述符，可以超过1024的限制。

epoll可以监控的文件描述符数量是可以打开文件的数量上限。与select和poll不同，epoll获取事件不是通过轮询得到，而是通过给每个文件描述符定义回调得到，因此，在监视的文件描述符很多的情况下，epoll的效率不会有明显的下降。并且，select和poll返回给应用程序的是所有的文件描述符，而epoll返回的是就绪(有事件发生的)的文件描述符。

JDK NIO包中的各种Selector

JDK中的Selector是一个抽象类，创建一个Selector通常以下面代码中的方式进行：

/**

* 代码片段1 创建Selector

*/

Selector selector = Selector.open();

下面是具体的实现：

/**

* 代码片段2 Selector中的open方法和SelectorProvider中的provider方法

*/

//调用SelectorProvider的openSelector创建Selector

public static Selector open() throws IOException {

return SelectorProvider.provider().openSelector();

}

//创建SelectorProvider，最终调用sun.nio.ch.DefaultSelectorProvider.create(), 这个方法在不同平台上有不同的实现

public static SelectorProvider provider() {

synchronized (lock) {

if (provider != null)

return provider;

return AccessController.doPrivileged(

new PrivilegedAction() {

public SelectorProvider run() {

if (loadProviderFromProperty())

return provider;

if (loadProviderAsService())

return provider;

provider = sun.nio.ch.DefaultSelectorProvider.create();

return provider;

}

});

}

}

在不同的操作系统平台下，SelectorProvider的实现也不相同，创建出来的Selector的实现也不一样。

windows下的多路复用实现

windows下的jdk中只有一个非抽象的SelectorProvider的实现类——WindowsSelectorProvider。显然，sun.nio.ch.DefaultSelectorProvider.create()返回的也是一个WindowsSelectorProvider对象：

/**

* 代码片段3 windows环境下jdk中的sun.nio.ch.DefaultSelectorProvider.create()方法

*/

public static SelectorProvider create() {

return new WindowsSelectorProvider();

}

WindowsSelectorProvider的openSelector方法会返回一个WindowsSelectorImpl对象,WindowsSelectorImpl继承了SelectorImpl这个抽象类：

/**

* 代码片段4

*/

public AbstractSelector openSelector() throws IOException {

return new WindowsSelectorImpl(this);

}

WindowsSelectorImpl的成员变量pollWrapper是一个PollArrayWrapper对象，PollArrayWrapper类在openjdk的源码中有这样的一段文档注释：

/**

* 代码片段5 windows下的PollArrayWrapper类中的注释

*/

/**

* Manipulates a native array of structs corresponding to (fd, events) pairs.

*

* typedef struct pollfd {

*    SOCKET fd;            // 4 bytes

*    short events;         // 2 bytes

* } pollfd_t;

*

* @author Konstantin Kladko

* @author Mike McCloskey

*/

PollArrayWrapper是用来操作(fd，events)对相对应的结构的原生数组。这个原生数组的结构就是上面的注释中的结构体所定义的。PollArrayWrapper类中通过操作AllocatedNativeObject类型的成员变量pollArray来操作文件描述符和事件。AllocatedNativeObject类继承了NativeObject类，NativeObject类型是驻留在本地内存中的对象的代理，提供了在堆外内存中存放和取出除boolean外的基本类型数据的方法。以byte类型为例，其存取方法如下：

/**

* 代码片段6  NativeObject中的getByte和putByte方法

*/

/**

* Reads a byte starting at the given offset from base of this native

* object.

*

* @param  offset

*         The offset at which to read the byte

*

* @return The byte value read

*/

final byte getByte(int offset) {

return unsafe.getByte(offset + address);

}

/**

* Writes a byte at the specified offset from this native object's

* base address.

*

* @param  offset

*         The offset at which to write the byte

*

* @param  value

*         The byte value to be written

*/

final void putByte(int offset, byte value) {

unsafe.putByte(offset + address,  value);

}

PollArrayWrapper中提供了方法存储事件和文件描述符，这些方法都通过来pollArray存取int和short类型，这些方法和PollArrayWrapper构造方法如下：

/**

* 代码片段7  PollArrayWrapper构造方法和对文件描述符和事件的操作方法

*/

PollArrayWrapper(int newSize) {

int allocationSize = newSize * SIZE_POLLFD;

pollArray = new AllocatedNativeObject(allocationSize, true);

pollArrayAddress = pollArray.address();

this.size = newSize;

}

// Access methods for fd structures

void putDescriptor(int i, int fd) {

pollArray.putInt(SIZE_POLLFD * i + FD_OFFSET, fd);

}

void putEventOps(int i, int event) {

pollArray.putShort(SIZE_POLLFD * i + EVENT_OFFSET, (short)event);

}

int getEventOps(int i) {

return pollArray.getShort(SIZE_POLLFD * i + EVENT_OFFSET);

}

int getDescriptor(int i) {

return pollArray.getInt(SIZE_POLLFD * i + FD_OFFSET);

}

因为pollfd结构体中，fd占用4个字节，events占用2个字节分别对应int和short的长度。FD_OFFSET，EVENT_OFFSET和SIZE_POLLFD分别是final修饰的int常量0，4和8。PollArrayWrapper会用8个字节来存储一个event和fd的配对，构造一个PollArrayWrapper对象会从堆外内存分配newSize8字节的空间。获取第i个fd则获取对应的第8i个字节对应的int，获取第i个event则只要获取第8*i+4个字节对应的short。所以构造一个size大小的PollArrayWrapper对象就可以存储size个fd，event对，并且他们在内存上是连续的(每对的空间末尾有2个字节用不到)，所以这也是一个数组。

Selector中的doSelect方法是具体对文件描述符的操作，WindowsSelectorImpl中的doSelector方法如下：

/**

* 代码片段8  WindowsSelectorImpl内部类SubSelector的poll方法中的doSelect方法及其调用的方法具体实现

*/

protected int doSelect(long timeout) throws IOException {

if (channelArray == null)

throw new ClosedSelectorException();

this.timeout = timeout; // set selector timeout

processDeregisterQueue();

if (interruptTriggered) {

resetWakeupSocket();

return 0;

}

//  计算轮询所需的辅助线程数。如果需要，在这里创建线程并开始等待startLock

adjustThreadsCount();

// 重置finishLock

finishLock.reset();

//  唤醒辅助线程，等待启动锁，线程启动后会开始轮询。冗余线程将在唤醒后退出。

startLock.startThreads();

// 在主线程中进行轮询。主线程负责pollArray中的前MAX_SELECTABLE_FDS(默认1024)个fd，event对。

try {

begin();

try {

subSelector.poll();

} catch (IOException e) {

// 保存异常

finishLock.setException(e);

}

//  主线程poll()调用结束。唤醒其他线程并等待他们

if (threads.size()0)

finishLock.waitForHelperThreads();

} finally {

end();

}

finishLock.checkForException();

processDeregisterQueue();

// 更新相应channel的操作。将就绪的key添加到就绪队列。

int updated = updateSelectedKeys();

// poll()调用完成。为下一次运行，将wakeupSocket设置为nonsigned。

resetWakeupSocket();

return updated;

}

//WindowsSelectorImpl内部类SubSelector的poll方法

private int poll() throws IOException{ // poll for the main thread

return poll0(pollWrapper.pollArrayAddress,

Math.min(totalChannels, MAX_SELECTABLE_FDS),

readFds, writeFds, exceptFds, timeout);

}

//WindowsSelectorImpl内部类SubSelector的poll0方法

private native int poll0(long pollAddress, int numfds,

int[] readFds, int[] writeFds, int[] exceptFds, long timeout);

poll0方法的C语言源码：

/**

* 代码片段9  WindowsSelectorImpl内部类SubSelector的poll方法的c源码

*/

JNIEXPORT jint JNICALL

Java_sun_nio_ch_WindowsSelectorImpl_00024SubSelector_poll0(JNIEnv *env, jobject this,

jlong pollAddress, jint numfds,

jintArray returnReadFds, jintArray returnWriteFds,

jintArray returnExceptFds, jlong timeout)

{

... //省略部分代码

/* Call select */

if ((result = select(0 , &readfds, &writefds, &exceptfds, tv))//调用系统的select函数

== SOCKET_ERROR) {

/* Bad error - this should not happen frequently */

/* Iterate over sockets and call select() on each separately */

FD_SET errreadfds, errwritefds, errexceptfds;

readfds.fd_count = 0;

writefds.fd_count = 0;

exceptfds.fd_count = 0;

for (i = 0; i < numfds; i++) {

/* prepare select structures for the i-th socket */

errreadfds.fd_count = 0;

errwritefds.fd_count = 0;

if (fds[i].events & POLLIN) {

errreadfds.fd_array[0] = fds[i].fd;

errreadfds.fd_count = 1;

}

if (fds[i].events & (POLLOUT | POLLCONN))

{

errwritefds.fd_array[0] = fds[i].fd;

errwritefds.fd_count = 1;

}

errexceptfds.fd_array[0] = fds[i].fd;

errexceptfds.fd_count = 1;

/* call select on the i-th socket */

if (select(0, &errreadfds, &errwritefds, &errexceptfds, &zerotime)//调用系统的select函数

== SOCKET_ERROR) {

/* This socket causes an error. Add it to exceptfds set */

exceptfds.fd_array[exceptfds.fd_count] = fds[i].fd;

exceptfds.fd_count++;

} else {

/* This socket does not cause an error. Process result */

if (errreadfds.fd_count == 1) {

readfds.fd_array[readfds.fd_count] = fds[i].fd;

readfds.fd_count++;

}

if (errwritefds.fd_count == 1) {

writefds.fd_array[writefds.fd_count] = fds[i].fd;

writefds.fd_count++;

}

if (errexceptfds.fd_count == 1) {

exceptfds.fd_array[exceptfds.fd_count] = fds[i].fd;

exceptfds.fd_count++;

}

}

}

}

... //省略部分代码

}

可见Window环境的JDK的nio是调用select系统函数来进行的。

linux下的多路复用实现

linux的jdk中有2个非抽象的Selector的子类——PollSelectorImpl和EPollSelectorImpl。

PollSelectorImpl

顾名思义，PollSelectorImpl是采用poll来进行多路复用。PollSelectorImpl继承了AbstractPollSelectorImpl。AbstractPollSelectorImpl中也维护了一个PollArrayWrapper来存储文件描述符和事件对,但linux下的PollArrayWrapper和windows下的实现并不相同。先看PollSelectorImpl的doSelect方法如下:

/**

* 代码片段10  PollSelectorImpl的doSelect方法

*/

protected int doSelect(long timeout)

throws IOException

{

if (channelArray == null)

throw new ClosedSelectorException();

processDeregisterQueue();

try {

begin();

pollWrapper.poll(totalChannels, 0, timeout);

} finally {

end();

}

processDeregisterQueue();

// 将pollfd结构中的信息复制到相应通道的ops中。将就绪的key添加到就绪队列。

int numKeysUpdated = updateSelectedKeys();

if (pollWrapper.getReventOps(0) != 0) {

// Clear the wakeup pipe

pollWrapper.putReventOps(0, 0);

synchronized (interruptLock) {

IOUtil.drain(fd0);

interruptTriggered = false;

}

}

return numKeysUpdated;

}

doSelect方法中会调用PollArrayWrapper中的poll方法，linux下的PollArrayWrapper和windows下的不太一样。PollArrayWrapper源码中的文档注释如下：

/**

* 代码片段11  linux下的PollArrayWrapper类中的注释

*/

/**

* Manipulates a native array of pollfd structs on Solaris:

*

* typedef struct pollfd {

*    int fd;

*    short events;

*    short revents;

* } pollfd_t;

*

* @author Mike McCloskey

* @since 1.4

*/

可以发现，与windows的相比，linux下的PollArrayWrapper操作的结构体多了一个revents(实际发生的事件)的字段，linux下的PollArrayWrapper类继承了抽象类AbstractPollArrayWrapper，AbstractPollArrayWrapper定义了对文件描述符和事件的操作方法：

/**

* 代码片段12  AbstractPollArrayWrapper中定义的几个final常量和对文件描述符、事件的操作方法

*/

static final short SIZE_POLLFD   = 8;

static final short FD_OFFSET     = 0;

static final short EVENT_OFFSET  = 4;

static final short REVENT_OFFSET = 6;

protected AllocatedNativeObject pollArray;

// Access methods for fd structures

int getEventOps(int i) {

int offset = SIZE_POLLFD * i + EVENT_OFFSET;

return pollArray.getShort(offset);

}

int getReventOps(int i) {

int offset = SIZE_POLLFD * i + REVENT_OFFSET;

return pollArray.getShort(offset);

}

int getDescriptor(int i) {

int offset = SIZE_POLLFD * i + FD_OFFSET;

return pollArray.getInt(offset);

}

void putEventOps(int i, int event) {

int offset = SIZE_POLLFD * i + EVENT_OFFSET;

pollArray.putShort(offset, (short)event);

}

void putReventOps(int i, int revent) {

int offset = SIZE_POLLFD * i + REVENT_OFFSET;

pollArray.putShort(offset, (short)revent);

}

void putDescriptor(int i, int fd) {

int offset = SIZE_POLLFD * i + FD_OFFSET;

pollArray.putInt(offset, fd);

}

可见，linux下的PollArrayWrapper中pollArray的每8个字节的后两个字节不是空，而是存储着两个字节的revents。PollArrayWrapper的poll方法如下：

/**

* 代码片段13  PollArrayWrapper中poll方法

*/

int poll(int numfds, int offset, long timeout) {

return poll0(pollArrayAddress + (offset * SIZE_POLLFD),

numfds, timeout);

}

private native int poll0(long pollAddress, int numfds, long timeout);

poll0方法的c语言源码：

/**

* 代码片段14  PollArrayWrapper中poll方法的c源码

*/

JNIEXPORT jint JNICALL

Java_sun_nio_ch_PollArrayWrapper_poll0(JNIEnv *env, jobject this,

jlong address, jint numfds,

jlong timeout)

{

struct pollfd *a;

int err = 0;

a = (struct pollfd *) jlong_to_ptr(address);

if (timeout <= 0) {           /* Indefinite or no wait */

//如果timeout<=0,立即调用系统的poll函数

RESTARTABLE (poll(a, numfds, timeout), err);

} else {                     /* Bounded wait; bounded restarts */

//如果timeout>0,会循环的调用poll函数直到到了timeout的时间

err = ipoll(a, numfds, timeout);

}

if (err < 0) {

JNU_ThrowIOExceptionWithLastError(env, "Poll failed");

}

return (jint)err;

}

static int ipoll(struct pollfd fds[], unsigned int nfds, int timeout)

{

jlong start, now;

int remaining = timeout;

struct timeval t;

int diff;

gettimeofday(&t, NULL);

start = t.tv_sec * 1000 + t.tv_usec / 1000;

for (;;) {

//调用poll函数 remaining是剩余的timeout，其实也就调用一次，用循环应该是为了防止poll函数的进程被异常唤醒

int res = poll(fds, nfds, remaining);

if (res < 0 && errno == EINTR) {

if (remaining >= 0) {

gettimeofday(&t, NULL);

now = t.tv_sec * 1000 + t.tv_usec / 1000;

diff = now - start;

remaining -= diff;

if (diff < 0 || remaining <= 0) {

return 0;

}

start = now;

}

} else {

return res;

}

}

}

可见PollSelectorImpl确实是调用系统的poll函数实现多路复用的。

EPollSelectorImpl

EPollSelectorImpl中使用EPollArrayWrapper来操作文件描述符和事件，EPollArrayWrapper中的对EPoll事件结构体的文档注释：

/**

* 代码片段15  EPollArrayWrapper类中的注释

*/

/**

* Manipulates a native array of epoll_event structs on Linux:

*

* typedef union epoll_data {

*     void *ptr;

*     int fd;

*     __uint32_t u32;

*     __uint64_t u64;

*  } epoll_data_t;

*

* struct epoll_event {

*     __uint32_t events;

*     epoll_data_t data;

* };

*

* The system call to wait for I/O events is epoll_wait(2). It populates an

* array of epoll_event structures that are passed to the call. The data

* member of the epoll_event structure contains the same data as was set

* when the file descriptor was registered to epoll via epoll_ctl(2). In

* this implementation we set data.fd to be the file descriptor that we

* register. That way, we have the file descriptor available when we

* process the events.

*/

等待IO时间的系统调用函数是epoll_wait(2)，它填充了一个epoll_event结构体的数组，这个数组被传递给系统调用。epoll_event结构的数据成员包含的数据与通过epoll_ctl(2)将文件描述符注册到epoll时设置的数据相同。在这个实现中，我们将data.fd设置为注册的文件描述符。这样，我们在处理事件时就有了可用的文件描述符。

很明显，EPollSelectorImpl中操作的结构体大小比PollSelectorImpl要大，这里不一一解读了。EPoll的调用和select、poll不同，需要调用三个系统函数，分别是epoll_create，epoll_ctl 和 epoll_wait，这点在JDK NIO中也得到验证。在EPollArrayWrapper创建时会调用epollCreate方法：

/**

* 代码片段16  EPollArrayWrapper的构造方法和构造方法中调用的epollCreate方法

*/

EPollArrayWrapper() throws IOException {

// creates the epoll file descriptor

epfd = epollCreate();

// the epoll_event array passed to epoll_wait

int allocationSize = NUM_EPOLLEVENTS * SIZE_EPOLLEVENT;

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<>();

}

private native int epollCreate();

这里的epollCreate方法也就是进行epoll_create系统调用，创建一个EPoll实例。以下是C源码：

/**

* 代码片段17  epollCreate方法的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.

*/

//进行epoll_create系统调用

int epfd = epoll_create(256);

if (epfd < 0) {

JNU_ThrowIOExceptionWithLastError(env, "epoll_create failed");

}

return epfd;

}

EPollSelectorImpl的构造方法中创建完成一个EPollArrayWrapper实例后，会执行该实例的initInterrupt方法，这个方法中调用了epollCtl方法：

/**

* 代码片段18  EPollSelectorImpl的构造方法、构造方法中调用的EPollArrayWrapper中的initInterrupt方法

* 和initInterrupt中调用的epollCtl方法

*/

/**

* Package private constructor called by factory method in

* the abstract superclass Selector.

*/

EPollSelectorImpl(SelectorProvider sp) throws IOException {

super(sp);

long pipeFds = IOUtil.makePipe(false);

fd0 = (int) (pipeFds >>> 32);

fd1 = (int) pipeFds;

pollWrapper = new EPollArrayWrapper();

//调用initInterrupt方法

pollWrapper.initInterrupt方法(fd0, fd1);

fdToKey = new HashMap<>();

}

void initInterrupt(int fd0, int fd1) {

outgoingInterruptFD = fd1;

incomingInterruptFD = fd0;

//调用epollCtl

epollCtl(epfd, EPOLL_CTL_ADD, fd0, EPOLLIN);

}

private native void epollCtl(int epfd, int opcode, int fd, int events);

这里的epollCtl方法也就是进行epoll_ctl系统调用，往刚刚创建的EPoll实例中添加要监控的事件。以下是C源码：

/**

* 代码片段19  epollCtl方法的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 = fd;

//调用epoll_ctl

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");

}

}

EPollSelectorImpl的doSelect方法会调用EPollArrayWrapper的poll方法，而在poll方法中会调用epollWait：

/**

* 代码片段20  EPollSelectorImpl中的doSelect方法、doSelect方法中调用的EPollArrayWrapper的poll方法

* 和poll方法中调用的epollWait方法

*/

protected int doSelect(long timeout) throws IOException {

if (closed)

throw new ClosedSelectorException();

processDeregisterQueue();

try {

begin();

pollWrapper.poll(timeout);

} finally {

end();

}

processDeregisterQueue();

int numKeysUpdated = updateSelectedKeys();

if (pollWrapper.interrupted()) {

// Clear the wakeup pipe

pollWrapper.putEventOps(pollWrapper.interruptedIndex(), 0);

synchronized (interruptLock) {

pollWrapper.clearInterrupted();

IOUtil.drain(fd0);

interruptTriggered = false;

}

}

return numKeysUpdated;

}

int poll(long timeout) throws IOException {

//更新注册信息，如果监视的实践发生变化，会调用epoll_ctl往Epoll实例中增加或删除事件

updateRegistrations();

//调用epollWait

updated = epollWait(pollArrayAddress, NUM_EPOLLEVENTS, timeout, epfd);

for (int i=0; i

if (getDescriptor(i) == incomingInterruptFD) {

interruptedIndex = i;

interrupted = true;

break;

}

}

return updated;

}

private native int epollWait(long pollAddress, int numfds, long timeout,

int epfd) throws IOException;

这里的epollWait方法也就是进行epoll_wait系统调用，调用者进程被挂起，在等待内核I/O事件的分发。以下是C源码：

/**

* 代码片段21  epollWait方法的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 */

//如果timeout<=0,立即调用系统的epoll_wait函数

RESTARTABLE(epoll_wait(epfd, events, numfds, timeout), res);

} else {                      /* Bounded wait; bounded restarts */

//如果timeout>0,循环调用直到超时时间到了，用循环应该是为了防止异常唤醒

res = iepoll(epfd, events, numfds, timeout);

}

if (res < 0) {

JNU_ThrowIOExceptionWithLastError(env, "epoll_wait failed");

}

return res;

}

总结

至此，本文已经对三种IO多路复用技术和在JDK中的应用进行了解读。在windows环境下，JDK NIO中只有WindowsSelectorImpl这有一个Selector的非抽象实现，采用的IO多路复用方式是select；在linux环境下PollSelectorImpl和EPollSelectorImpl两种实现，分别采用poll和epoll实现IO多路复用。本文还对这些Selector的具体实现进行了详细的解读，不足之处，敬请指正。