JavaNIO核心源码解密：Selector与Epoll底层实现探秘

最新推荐文章于 2025-10-20 08:31:15 发布
原创 最新推荐文章于 2025-10-20 08:31:15 发布 · 444 阅读 · 6 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#java #CSDN

Java NIO核心源码解密：Selector与Epoll底层实现探秘



深入剖析Java NIO中Selector的底层实现机制，揭秘Epoll在Linux系统上的高性能网络编程原理



1. NIO Selector核心架构解析


Java NIO（New I/O）的选择器（Selector）是Java高性能网络编程的核心组件。它允许单个线程监控多个Channel的IO事件，极大地提升了服务器的并发处理能力。


1.1 Selector的基本使用


首先让我们通过一个简单的代码示例了解Selector的基本用法：


```java
public class NioServerExample {
private static final int PORT = 8080;


public static void main(String[] args) throws IOException {

    // 创建Selector实例

    Selector selector = Selector.open();



    // 创建服务器通道

    ServerSocketChannel serverChannel = ServerSocketChannel.open();

    serverChannel.configureBlocking(false);

    serverChannel.bind(new InetSocketAddress(PORT));



    // 将服务器通道注册到Selector，监听ACCEPT事件

    serverChannel.register(selector, SelectionKey.OP_ACCEPT);



    System.out.println("服务器启动，监听端口：" + PORT);



    while (true) {

        // 阻塞等待就绪的Channel

        int readyChannels = selector.select();



        if (readyChannels == 0) continue;



        // 获取就绪的SelectionKey集合

        Set<SelectionKey> selectedKeys = selector.selectedKeys();

        Iterator<SelectionKey> keyIterator = selectedKeys.iterator();



        while (keyIterator.hasNext()) {

            SelectionKey key = keyIterator.next();



            if (key.isAcceptable()) {

                // 处理新连接

                handleAccept(key, selector);

            } else if (key.isReadable()) {

                // 处理读事件

                handleRead(key);

            } else if (key.isWritable()) {

                // 处理写事件

                handleWrite(key);

            }



            keyIterator.remove();

        }

    }

}



private static void handleAccept(SelectionKey key, Selector selector) 

        throws IOException {

    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();

    SocketChannel clientChannel = serverChannel.accept();

    clientChannel.configureBlocking(false);



    // 注册读事件

    clientChannel.register(selector, SelectionKey.OP_READ);

    System.out.println("新的客户端连接: " + clientChannel.getRemoteAddress());

}



private static void handleRead(SelectionKey key) throws IOException {

    SocketChannel channel = (SocketChannel) key.channel();

    ByteBuffer buffer = ByteBuffer.allocate(1024);



    int bytesRead = channel.read(buffer);

    if (bytesRead > 0) {

        buffer.flip();

        byte[] data = new byte[buffer.remaining()];

        buffer.get(data);

        String message = new String(data);

        System.out.println("收到消息: " + message);



        // 注册写事件，准备回显数据

        key.interestOps(SelectionKey.OP_WRITE);

    } else if (bytesRead < 0) {

        channel.close();

    }

}



private static void handleWrite(SelectionKey key) throws IOException {

    SocketChannel channel = (SocketChannel) key.channel();

    String response = "服务器响应时间: " + System.currentTimeMillis();

    ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());



    while (buffer.hasRemaining()) {

        channel.write(buffer);

    }



    // 重新注册读事件

    key.interestOps(SelectionKey.OP_READ);

}

}
```


2. SelectorProvider与底层实现


2.1 Selector的创建过程


在Linux系统上，Java NIO默认使用Epoll实现。让我们深入源码看看Selector的创建过程：


```java
public abstract class Selector implements Closeable {
// Selector的open方法最终调用SelectorProvider
public static Selector open() throws IOException {
return SelectorProvider.provider().openSelector();
}
}


// 在Linux系统上，默认的SelectorProvider是EPollSelectorProvider
public class EPollSelectorProvider extends SelectorProvider {
public EPollSelectorProvider() {
// 验证epoll可用性
ensureAvailable();
}


@Override

public AbstractSelector openSelector() throws IOException {

    return new EPollSelectorImpl(this);

}



private static void ensureAvailable() {

    // 检查系统是否支持epoll

    if (!isAvailable()) {

        throw new UnsupportedOperationException("EPoll not available");

    }

}



private static native boolean isAvailable();

}
```


2.2 EPollSelectorImpl核心实现


```java
class EPollSelectorImpl extends SelectorImpl {
// 文件描述符，对应epoll实例
private final int epfd;


// epoll_event数组，用于接收就绪事件

private final long address;



// 注册的通道映射

private final Map<Integer, SelectionKey> fdToKey;



EPollSelectorImpl(SelectorProvider sp) throws IOException {

    super(sp);

    // 创建epoll实例

    this.epfd = EPoll.create();

    this.address = EPoll.allocatePollArray(MAX_EPOLL_EVENTS);

    this.fdToKey = new HashMap<>();

}



@Override

protected int doSelect(long timeout) throws IOException {

    int numKeys = keys.size();

    if (numKeys == 0) {

        // 没有注册的通道，直接返回

        return 0;

    }



    // 调用epoll_wait系统调用

    int n = EPoll.wait(epfd, address, MAX_EPOLL_EVENTS, timeout);



    // 处理就绪的事件

    for (int i = 0; i < n; i++) {

        long event = EPoll.getEvent(address, i);

        int fd = EPoll.getDescriptor(event);

        int events = EPoll.getEvents(event);



        SelectionKey sk = fdToKey.get(fd);

        if (sk != null) {

            // 更新就绪的操作集

            int readyOps = 0;

            if ((events & EPoll.EPOLLIN) != 0) 

                readyOps |= SelectionKey.OP_READ;

            if ((events & EPoll.EPOLLOUT) != 0)

                readyOps |= SelectionKey.OP_WRITE;

            if ((events & (EPoll.EPOLLERR | EPoll.EPOLLHUP)) != 0)

                readyOps = readyOps | SelectionKey.OP_READ | SelectionKey.OP_WRITE;



            // 更新SelectionKey的就绪操作集

            sk.nioReadyOps(readyOps);

        }

    }



    return n;

}

}
```


3. Epoll底层机制深度解析


3.1 Epoll的系统调用封装


Java通过JNI调用底层的epoll系统调用，让我们看看这个过程的实现：


```java
// EPoll类的native方法声明
class EPoll {
private static final int EPOLL_CTL_ADD = 1;
private static final int EPOLL_CTL_MOD = 2;
private static final int EPOLL_CTL_DEL = 3;


// 创建epoll实例

static native int create() throws IOException;



// 封装epoll_ctl系统调用

static native int ctl(int epfd, int opcode, int fd, int events) 

    throws IOException;



// 封装epoll_wait系统调用

static native int wait(int epfd, long address, int numfds, long timeout) 

    throws IOException;



// 分配epoll_event数组

static native long allocatePollArray(int numfds);



// 从事件数组中获取事件信息

static native long getEvent(long address, int i);

static native int getDescriptor(long event);

static native int getEvents(long event);

}
```


对应的JNI实现（C语言）：


```c
JNIEXPORT jint JNICALL
Java_sun_nio_ch_EPoll_create(JNIEnv env, jclass clazz) {
int epfd = epoll_create(256); // size参数在现代Linux中已忽略
if (epfd < 0) {
JNU_ThrowIOExceptionWithLastError(env, "epoll_create failed");
}
return epfd;
}


JNIEXPORT jint JNICALL
Java_sun_nio_ch_EPoll_ctl(JNIEnv env, jclass clazz,
jint epfd, jint op, jint fd, jint events) {
struct epoll_event event;
int res;


event.events = events;

event.data.fd = fd;



res = epoll_ctl(epfd, op, fd, &event);

if (res < 0) {

    JNU_ThrowIOExceptionWithLastError(env, "epoll_ctl failed");

}

return res;

}


JNIEXPORT jint JNICALL

Java_sun_nio_ch_EPoll_wait(JNIEnv env, jclass clazz,
jint epfd, jlong address, jint numfds, jlong timeout) {
struct epoll_event events = (struct epoll_event )jlong_to_ptr(address);
int res;


if (timeout <= 0) {

    timeout = -1;  // 无限等待

} else if (timeout > INT_MAX) {

    timeout = INT_MAX;

}



res = epoll_wait(epfd, events, numfds, (int)timeout);

if (res < 0) {

    if (errno == EINTR) {

        return 0;  // 被信号中断

    }

    JNU_ThrowIOExceptionWithLastError(env, "epoll_wait failed");

}

return res;

}
```


3.2 Channel注册的完整流程


当我们将Channel注册到Selector时，底层的完整流程如下：


```java
public abstract class AbstractSelectableChannel extends SelectableChannel {
protected final Object regLock = new Object();


@Override

public final SelectionKey register(Selector sel, int ops, Object att)

    throws ClosedChannelException {

    synchronized (regLock) {

        if (!isOpen())

            throw new ClosedChannelException();

        if ((ops & ~validOps()) != 0)

            throw new IllegalArgumentException();



        // 获取或创建SelectionKey

        SelectionKey k = findKey(sel);

        if (k != null) {

            k.interestOps(ops);

            k.attach(att);

        }

        if (k == null) {

            // 新注册

            k = ((AbstractSelector)sel).register(this, ops, att);

            addKey(k);

        }

        return k;

    }

}

}


class EPollSelectorImpl extends SelectorImpl {
public SelectionKey register(AbstractSelectableChannel ch, int ops, Object att) {
if (!(ch instanceof SelChImpl))
throw new IllegalSelectorException();


    // 创建EPollSelectionKey

    SelectionKeyImpl k = new EPollSelectionKeyImpl((AbstractSelector)this, ch);

    k.attach(att);



    synchronized (publicKeys) {

        // 添加到键集合

        implRegister(k);

    }



    k.interestOps(ops);

    return k;

}



@Override

protected void implRegister(SelectionKeyImpl ski) {

    SelChImpl ch = ski.channel;

    int fd = ch.getFDVal();



    synchronized (fdToKey) {

        fdToKey.put(fd, ski);

    }



    // 初始关注的事件为0

    ski.interestOps = 0;

}

}
```


4. 高性能网络服务器实战


基于对Selector和Epoll底层机制的理解，我们可以实现一个高性能的Echo服务器：


```java
public class HighPerformanceEchoServer {
private static final int PORT = 8080;
private static final int BUFFER_SIZE = 1024;
private Selector selector;
private ServerSocketChannel serverChannel;
private final ByteBuffer readBuffer = ByteBuffer.allocate(BUFFER_SIZE);


public void start() throws IOException {

    initServer();

    eventLoop();

}



private void initServer() throws IOException {

    selector = Selector.open();

    serverChannel = ServerSocketChannel.open();

    serverChannel.configureBlocking(false);

    serverChannel.bind(new InetSocketAddress(PORT));

    serverChannel.register(selector, SelectionKey.OP_ACCEPT);

    System.out.println("高性能Echo服务器启动，端口：" + PORT);

}



private void eventLoop() {

    while (true) {

        try {

            // 设置1秒超时，避免无限阻塞

            if (selector.select(1000) == 0) {

                continue;

            }



            Iterator<SelectionKey> keyIter = selector.selectedKeys().iterator();

            while (keyIter.hasNext()) {

                SelectionKey key = keyIter.next();

                keyIter.remove();



                if (!key.isValid()) {

                    continue;

                }



                try {

                    if (key.isAcceptable()) {

                        acceptConnection(key);

                    } else if (key.isReadable()) {

                        readData(key);

                    } else if (key.isWritable()) {

                        writeData(key);

                    }

                } catch (IOException e) {

                    key.cancel();

                    try {

                        key.channel().close();

                    } catch (IOException ex) {

                        // 忽略关闭异常

                    }

                }

            }

        } catch (IOException e) {

            e.printStackTrace();

        }

    }

}



private void acceptConnection(SelectionKey key) throws IOException {

    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();

    SocketChannel clientChannel = serverChannel.accept();

    clientChannel.configureBlocking(false);



    // 注册读事件，并附加一个Attachment用于状态管理

    ClientAttachment attachment = new ClientAttachment();

    clientChannel.register(selector, SelectionKey.OP_READ, attachment);



    System.out.println("接受新连接: " + clientChannel.getRemoteAddress());

}



private void readData(SelectionKey key) throws IOException {

    SocketChannel channel = (SocketChannel) key.channel();

    ClientAttachment attachment = (ClientAttachment) key.attachment();



    readBuffer.clear();

    int bytesRead = channel.read(readBuffer);



    if (bytesRead == -1) {

        // 连接关闭

        channel.close();

        key.cancel();

        System.out.println("客户端断开连接");

        return;

    }



    if (bytesRead > 0) {

        readBuffer.flip();

        byte[] data = new byte[readBuffer.remaining()];

        readBuffer.get(data);

        String message = new String(data).trim();



        System.out.println("收到消息: " + message);



        // 准备回写数据

        attachment.setResponseData(("Echo: " + message).getBytes());



        // 注册写事件

        key.interestOps(SelectionKey.OP_WRITE);

    }

}



private void writeData(SelectionKey key) throws IOException {

    SocketChannel channel = (SocketChannel) key.channel();

    ClientAttachment attachment = (ClientAttachment) key.attachment();



    ByteBuffer writeBuffer = attachment.getWriteBuffer();

    if (writeBuffer.hasRemaining()) {

        channel.write(writeBuffer);

    }



    if (!writeBuffer.hasRemaining()) {

        // 数据发送完成，重新注册读事件

        key.interestOps(SelectionKey.OP_READ);

    }

}



// 客户端连接附件，用于状态管理

private static class ClientAttachment {

    private ByteBuffer writeBuffer;



    public void setResponseData(byte[] data) {

        this.writeBuffer = ByteBuffer.wrap(data);

    }



    public ByteBuffer getWriteBuffer() {

        return writeBuffer;

    }

}



public static void main(String[] args) throws IOException {

    new HighPerformanceEchoServer().start();

}

}
```


5. 性能优化与实践建议


5.1 Selector使用的最佳实践


```java
public class SelectorOptimization {


// 1. 合理设置Selector超时时间

public void optimizedSelect() throws IOException {

    Selector selector = Selector.open();



    // 设置合理的超时时间，避免CPU空转

    while (true) {

        // 推荐设置1-100毫秒的超时

        int readyChannels = selector.select(10); // 10毫秒超时



        if (readyChannels > 0) {

            processSelectedKeys(selector);

        } else {

            // 可以在这里执行一些后台任务

            doBackgroundWork();

        }

    }

}



// 2. 批量处理就绪的Channel

private void processSelectedKeys(Selector selector) throws IOException {

    Set<SelectionKey> selectedKeys = selector.selectedKeys();



    // 使用迭代器而不是foreach，避免ConcurrentModificationException

    Iterator<SelectionKey> keyIterator = selectedKeys.iterator();



    int processedCount = 0;

    int maxBatchSize = 1000; // 每批次最大处理数量



    while (keyIterator.hasNext() && processedCount < maxBatchSize) {

        SelectionKey key = keyIterator.next();

        keyIterator.remove();



        if (key.isValid()) {

            processKey(key);

            processedCount++;

        }

    }

}



// 3. 避免在IO线程中执行耗时操作

private void processKey(SelectionKey key) throws IOException {

    if (key.isReadable()) {

        // 快速读取数据，放入队列处理

        SocketChannel channel = (SocketChannel) key.channel();

        ByteBuffer buffer = ByteBuffer.allocate(1024);



        int bytesRead = channel.read(buffer);

        if (bytesRead > 0) {

            buffer.flip();

            // 将数据提交到业务线程池处理

            submitToWorkerPool(buffer);

        }

    }

}



private void submitToWorkerPool(ByteBuffer buffer) {

    // 使用线程池处理业务逻辑

    Executors.newCachedThreadPool().submit(() -> {

        // 业务处理逻辑

        processBusinessLogic(buffer);

    });

}

}
```


5.2 内存管理优化


```java
public class BufferPool {
private final Queue bufferPool = new ConcurrentLinkedQueue<>();
private final int bufferSize;
private final int poolSize;


public BufferPool(int bufferSize, int poolSize) {

    this.bufferSize = bufferSize;

    this.poolSize = poolSize;

    initializePool();

}



private void initializePool() {

    for (int i = 0; i < poolSize; i++) {

        bufferPool.offer(ByteBuffer.allocateDirect(bufferSize));

    }

}



public ByteBuffer acquire() {

    ByteBuffer buffer = bufferPool.poll();

    if (buffer == null) {

        // 池为空，创建新的直接缓冲区

        buffer = ByteBuffer.allocateDirect(bufferSize);

    }

    buffer.clear(); // 重置缓冲区

    return buffer;

}



public void release(ByteBuffer buffer) {

    if (bufferPool.size() < poolSize) {

        buffer.clear();

        bufferPool.offer(buffer);

    }

    // 如果池已满，让缓冲区被GC回收

}

}
```


6. 总结


通过深入分析Java NIO中Selector与Epoll的底层实现，我们可以得出以下重要结论：



  2. 高性能基础：Java NIO在Linux系统上默认使用Epoll实现，提供了O(1)时间复杂度的事件通知机制

  4. 水平触发模式：Java NIO使用Epoll的水平触发（LT）模式，确保数据不会丢失

  6. 单线程多路复用：Selector允许单个线程高效管理成千上万的网络连接

  8. 零拷贝优化：结合DirectByteBuffer可以减少内存拷贝次数


理解这些底层机制对于编写高性能网络应用程序至关重要。在实际开发中，我们应该：
- 合理设置Selector超时时间
- 使用缓冲区池减少内存分配开销
- 避免在IO线程中执行耗时操作
- 合理处理背压和流量控制


通过结合理论知识和实践优化，我们可以构建出能够处理海量并发连接的高性能网络服务器。


2501_93727995
关注
Java NIO详解及源码下载
03-20
博客地址：http://blog.csdn.net/u010156024/article/details/44310709 欢迎访问。 代码中详细讲述了Java io流和nio流的用法，可以参考学习。
java的IO模型和IO多路复用的底层原理（select,poll,epoll）
m0_56184347的博客
04-25 1903
IO多路复用的引入思路 首先针对于服务器而言，如果客户端有多个请求的解决方案？ 方案1，最直接最简单的实现就是创建多个线程来对应多个请求，提高请求的处理速度，但是一些特定的场景下，由于多个线程之间来回的上下文切换，会导致系统开销加大 方案2，使用单线程，使用单线程来处理的话，可以避免多个线程之间来回的切换，如redis就是单线程的，底层是一个文件事件处理器，采用io多路复用模型，有多个socket来对请求进行监听，当有多个socket都有请求来的时候，需要判断哪些socket有请求，需要针对有请求的soc.
NIO多路复用底层原理(Select、Poll、EPoll)
qq_41563912的博客
09-06 6691
NIO一、NIO概述1. BIO2. NIO二、文件描述符三、Select、Poll、EPoll1. Select2. Poll模型3. EPoll模型四、总结1. 大致过程如下: 一、NIO概述 1. BIO         BIO，即Blockig IO，阻塞IO，一个线程对应一个连接，如果你的服务器有很多用户，每个用户都需要与你的服务器建立一个连接，那么你有多少用户，你的服务器就得创建多少个线程，显然是不显示的，而且每个线
JAVA面试题分享二百八十：一次穿透NIO、Selector、Epoll底层原理
之乎者也·的博客
12-17 1514
当struct file，struct socket，struct sock这些核心的内核对象创建好之后，最后就是把socket对象对应的struct file放到进程打开的文件列表fd_array中。随后系统调用accept返回socket的文件描述符fd给用户程序。
selector、epoll详解
sinat_38705282的博客
05-15 2431
文章目录基础一、Selector1.1 原理1.2 示例二、epoll2.1 原理2.2 示例2.3 总体流程三、Reactor 基础 首先，我们要明确同步、异步的层级。在这里讨论经常会出现各种同步、异步的概念让人迷惑，例如Netty用的是多路复用，而多路复用是同步非阻塞的I/O模型，但是Netty却宣称自己是异步的处理框架。其实这都是因为这里的同步、异步是针对不同线程，不同层级来说的。 同步、异步在I/O模型中是针对I/O线程的，但是在后面的Reactor模型中是针对业务线程。所以Netty是一个异步框架
JAVA NIO的selector的实现原理
donsonzhang的专栏
06-24 1万+
Java NIO的核心类库多路复用器Selector就是基于epoll的多路复用技术实现的 相比select、poll系统调用，epoll有如下优点：1.支持一个进程打开的socket描述符(FD)不受限制，仅受限于操作系统的最大文件句柄数。 select最大的缺陷是单个进程所打开的FD是有一定限制的，它由FD_SETSIZE设置，默认值是1024。可以选择修改这个宏后重新编译内核，但这对带来网
【Java源码阅读系列43】Java NIO Buffer 源码深度解读
专注Java和MySQL领域知识分享
07-09 790
Java NIO（New Input/Output）中的 Buffer 类是所有缓冲区（如 ByteBuffer、IntBuffer 等）的抽象基类，是实现高效 IO 操作的核心组件。其源码通过状态变量管理和设计模式的巧妙结合，实现了对数据读写的灵活控制。本文将结合 Buffer 类的源码，深入解析其核心机制、关键方法及设计模式的应用。
Java NIO详解及源码分析_java nio源码
2401_85956979的博客
08-21 1181
limit 代表最多能写入或者读取多少单位的数据，写模式下等于最大容量 capacity；从写模式切换到读模式时，等于position，然后再将 position 置为 0，所以，读模式下，limit 表示最大可读取的数据量，这个值与实际写入的数量相等。capacity 表示 buffer 容量，创建时分配。
深度解析Java NIO底层实现原理（初探服务器端程序）
猿上生活
06-24 1536
原创不易，转载请注明出处 java 版本1.8 文章目录前言1.一段基于java nio实现的服务端程序2.ServerSocketChannel是怎样open的总结 前言 本文主要从源码角度剖析java nio，文章定位属于高级进阶篇，所以在看本文之前需要有几点要求： 对java nio有所了解，同时也需要对linux 网络编程有所了解，特别是epoll。 本文分析的jdk源码是1.8，因为java nio根据不同操作系统有不同的底层实现，我们为了更贴近生产级别，会剖析基于linux实现的那部分，.
深入理解NIO底层源码——进阶
qq_35347200的博客
02-23 1622
NIO源码详解
JavaIO与NIO源码结构分析：从文件操作到网络通信
sqZYjXiAk的博客
10-16 336
Java 并发性能测试 JMH 框架编写基准测试用例实战
JavaIO与NIO源码深度解析：从文件操作到网络通信的实现
最新发布
W537565的博客
10-20 1368
特性 | Java IO | Java NIO || 编程模型 | 同步阻塞 | 同步非阻塞 || 线程模型 | 连接线程1:1 | 多路复用1:N || 吞吐量 | 连接数少时较高 | 连接数多时优势明显 || 代码复杂度 | 简单直观 | 相对复杂 |Java IO与NIO代表了两种不同的I/O编程范式。IO模型简单直接，适合连接数不多的场景；NIO通过多路复用技术，大幅提升了高并发下的性能表现。深入理解其源码实现，有助于我们在实际开发中做出合理的技术选型，编写出更高效的应用程序。
select、poll、epoll的底层原理剖析
lt_xiaodou的博客
10-05 1227
/ 定义位于/sys/select.h文件中复制代码nfds ：表示 FDS 中有效的 FD 数量，全部文件描述符的最大值 +1。readfds ：表示需要监控读事件发生的文件描述符集合。writefds ：表示需要监控写事件发生的文件描述符集合。exceptfds ：表示需要监控异常/错误发生的文件描述符集合。timeout ：表示 select 在没有事件触发的情况下，会阻塞的时间。
Selector与Epoll
Never too late to study
11-19 1783
我想用这个话题小结下最近这一阶段的各种测试和开发。其实文章的内容主要还是想总结一下NIO Socket. 问题应该从服务器端开始说起。我们都写过net包下的socket，用socket的accept方法来等待客户端的请求，请求来了则处理，没有则一直等待，然后反复循环。这样的方式，类似于重用进程，要说线程也可以，始终就在这一条路上堵着。这样没有并发可言，我们想到了可以用多线程，用线程池的方式来
Java NIO 选择器(Selector)的内部实现（poll epoll）
热门推荐
Hsuxu的专栏
08-10 3万+
之前强调这么多关于linux内核的poll及epoll，无非是想让大家先有个认识： Java NIO中的选择器依赖操作系统内核的这些系统调用，我们这里只讲解与linux内核相关的NIO实现，当然，windows或其他操作系统实现大体上是类似的，相信大家也可以触类旁通。 那么，本文从这里将从简到难，一步一步为大家讲解选择器的点点滴滴吧。 选择器的宏观理解 “有这么一种
Java NIO系列教程（七） selector原理 Epoll版的Selector
weixin_33739627的博客
04-28 1047
目录：   Reactor（反应堆）和Proactor（前摄器） 《I/O模型之三：两种高性能 I/O 设计模式 Reactor 和 Proactor》 《【转】第8章 前摄器（Proactor）：用于为异步事件多路分离和分派处理器的对象行为模式》 《Java NIO系列教程（八）JDK AIO编程》-- java AIO的proactor模式 《Java NIO系列教程（七） sel...
谈谈java selector的机制
helpbs
04-12 803
1）常用数据结构 EPollSelectorImpl 维护了3个键set keys【已经注册的键的集合】 selectedKeys【已选择的键的集合】 cancelledKeys【已取消的键的集合】 EPollArrayWrapper【真正的对linux epoll的封装】 包含了3个重要的native方法epollCreate、epollCtl、epollWait分别对应库函数...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值