jdk的Selector(3)select的过程

最新推荐文章于 2024-04-08 10:00:00 发布
最新推荐文章于 2024-04-08 10:00:00 发布
阅读量593 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： jdk 文章标签： nio jdk 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_40318210/article/details/79070142
本文深入剖析了Java NIO中Selector的实现机制，详细介绍了Selector处理I/O事件的流程，包括如何通过调整线程数来提高效率，以及如何处理已取消注册的Channel。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

当调用了SelectorImpl的select()方法的时候，同时会将所带的参数，也就是给select()所设置的timeout，之后会调用lockAndDoSelect()，在这个方法中，主要还是调用了doSelect()方法，参数与传进来的一致。以WindowsSelectorImpl为例子，实现的deSelect()方法。

protected int doSelect(long var1) throws IOException {
    if(this.channelArray == null) {
        throw new ClosedSelectorException();
    } else {
        this.timeout = var1;
        this.processDeregisterQueue();
        if(this.interruptTriggered) {
            this.resetWakeupSocket();
            return 0;
        } else {
            this.adjustThreadsCount();
            this.finishLock.reset();
            this.startLock.startThreads();

            try {
                this.begin();

                try {
                    this.subSelector.poll();
                } catch (IOException var7) {
                    this.finishLock.setException(var7);
                }

                if(this.threads.size() > 0) {
                    this.finishLock.waitForHelperThreads();
                }
            } finally {
                this.end();
            }

            this.finishLock.checkForException();
            this.processDeregisterQueue();
            int var3 = this.updateSelectedKeys();
            this.resetWakeupSocket();
            return var3;
        }
    }
}

 

首先，会调用processDeregisterQueue()方法，来将已经准备解除注册的channel进行解除注册。

 

void processDeregisterQueue() throws IOException {
    Set var1 = this.cancelledKeys();
    synchronized(var1) {
        if(!var1.isEmpty()) {
            Iterator var3 = var1.iterator();

            while(var3.hasNext()) {
                SelectionKeyImpl var4 = (SelectionKeyImpl)var3.next();

                try {
                    this.implDereg(var4);
                } catch (SocketException var12) {
                    IOException var6 = new IOException("Error deregistering key");
                    var6.initCause(var12);
                    throw var6;
                } finally {
                    var3.remove();
                }
            }
        }

    }
}

 

在这里，会取得所有需要取消注册的SelectionKey，并且依次调用implDereg()进行解除绑定。

 

protected void implDereg(SelectionKeyImpl var1) throws IOException {
    int var2 = var1.getIndex();

    assert var2 >= 0;

    Object var3 = this.closeLock;
    synchronized(this.closeLock) {
        if(var2 != this.totalChannels - 1) {
            SelectionKeyImpl var4 = this.channelArray[this.totalChannels - 1];
            this.channelArray[var2] = var4;
            var4.setIndex(var2);
            this.pollWrapper.replaceEntry(this.pollWrapper, this.totalChannels - 1, this.pollWrapper, var2);
        }

        var1.setIndex(-1);
    }

    this.channelArray[this.totalChannels - 1] = null;
    --this.totalChannels;
    if(this.totalChannels != 1 && this.totalChannels % 1024 == 1) {
        --this.totalChannels;
        --this.threadsCount;
    }

    this.fdMap.remove(var1);
    this.keys.remove(var1);
    this.selectedKeys.remove(var1);
    this.deregister(var1);
    SelectableChannel var7 = var1.channel();
    if(!var7.isOpen() && !var7.isRegistered()) {
        ((SelChImpl)var7).kill();
    }

}

 

如果需要解除注册的channel已经是selector当中最后一个了，那么直接从数组中移走就行，但如果没有，则需要与数组最后一个索引位置上的交换位置，保证数组中间位置的连续，再将其移除，后面的操作与注册的操作相似，但都是反向操作。

 

在完成取消注册的步骤后，将会调用adjustThreadCount()方法来调整线程的数量，具体看下面的方法。

private void adjustThreadsCount() {
    int var1;
    if(this.threadsCount > this.threads.size()) {
        for(var1 = this.threads.size(); var1 < this.threadsCount; ++var1) {
            WindowsSelectorImpl.SelectThread var2 = new WindowsSelectorImpl.SelectThread(var1);
            this.threads.add(var2);
            var2.setDaemon(true);
            var2.start();
        }
    } else if(this.threadsCount < this.threads.size()) {
        for(var1 = this.threads.size() - 1; var1 >= this.threadsCount; --var1) {
            ((WindowsSelectorImpl.SelectThread)this.threads.remove(var1)).makeZombie();
        }
    }

}

 

在Selector中，每有1024条channel，就需要重新开一个线程加入完成监听的操作，这里是从新根据当前应该有的线程数量与此时现存的线程数量进行比较，动态调整。

 

在这之后，调用了begin()方法，准备开始正式进行select操作。

protected final void begin() {
    if (interruptor == null) {
        interruptor = new Interruptible() {
                public void interrupt(Thread ignore) {
                    AbstractSelector.this.wakeup();
                }};
    }
    AbstractInterruptibleChannel.blockedOn(interruptor);
    Thread me = Thread.currentThread();
    if (me.isInterrupted())
        interruptor.interrupt(me);
}

 

在这里的begin()方法判断了这里的interruptor是否为空，如果为空，则会在这里重新生成一个，这里的Interruptor保证了当线程阻塞在了Io操作上，并且被interruptor时，保证selecor能够被唤醒。

 

在begin()方法执行完毕之后，将会调用其subSelector的poll()方法，正式开始select操作。

private int poll() throws IOException {
    return this.poll0(WindowsSelectorImpl.this.pollWrapper.pollArrayAddress, Math.min(WindowsSelectorImpl.this.totalChannels, 1024), this.readFds, this.writeFds, this.exceptFds, WindowsSelectorImpl.this.timeout);
}

private int poll(int var1) throws IOException {
    return this.poll0(WindowsSelectorImpl.this.pollWrapper.pollArrayAddress + (long)(this.pollArrayIndex * PollArrayWrapper.SIZE_POLLFD), Math.min(1024, WindowsSelectorImpl.this.totalChannels - (var1 + 1) * 1024), this.readFds, this.writeFds, this.exceptFds, WindowsSelectorImpl.this.timeout);
}

private native int poll0(long var1, int var3, int[] var4, int[] var5, int[] var6, long var7);

 

这里的poll0()还是原生方法的实现。主要是为了监听pollWrapper中所保存的fd是否有数据进出，如果没有进出，则会在在此处在timeout的时间里一直保持阻塞状态。

 

当完成数据监听，取得相应的数据的时候，在这之后，将会重新检验并取消一边已经被取消的channel之后调用updateSelectedKeys()方法。

private int processSelectedKeys(long var1) {
    byte var3 = 0;
    int var4 = var3 + this.processFDSet(var1, this.readFds, 1, false);
    var4 += this.processFDSet(var1, this.writeFds, 6, false);
    var4 += this.processFDSet(var1, this.exceptFds, 7, true);
    return var4;
}

private int processFDSet(long var1, int[] var3, int var4, boolean var5) {
    int var6 = 0;

    for(int var7 = 1; var7 <= var3[0]; ++var7) {
        int var8 = var3[var7];
        if(var8 == WindowsSelectorImpl.this.wakeupSourceFd) {
            synchronized(WindowsSelectorImpl.this.interruptLock) {
                WindowsSelectorImpl.this.interruptTriggered = true;
            }
        } else {
            WindowsSelectorImpl.MapEntry var9 = WindowsSelectorImpl.this.fdMap.get(var8);
            if(var9 != null) {
                SelectionKeyImpl var10 = var9.ski;
                if(!var5 || !(var10.channel() instanceof SocketChannelImpl) || !WindowsSelectorImpl.this.discardUrgentData(var8)) {
                    if(WindowsSelectorImpl.this.selectedKeys.contains(var10)) {
                        if(var9.clearedCount != var1) {
                            if(var10.channel.translateAndSetReadyOps(var4, var10) && var9.updateCount != var1) {
                                var9.updateCount = var1;
                                ++var6;
                            }
                        } else if(var10.channel.translateAndUpdateReadyOps(var4, var10) && var9.updateCount != var1) {
                            var9.updateCount = var1;
                            ++var6;
                        }

                        var9.clearedCount = var1;
                    } else {
                        if(var9.clearedCount != var1) {
                            var10.channel.translateAndSetReadyOps(var4, var10);
                            if((var10.nioReadyOps() & var10.nioInterestOps()) != 0) {
                                WindowsSelectorImpl.this.selectedKeys.add(var10);
                                var9.updateCount = var1;
                                ++var6;
                            }
                        } else {
                            var10.channel.translateAndUpdateReadyOps(var4, var10);
                            if((var10.nioReadyOps() & var10.nioInterestOps()) != 0) {
                                WindowsSelectorImpl.this.selectedKeys.add(var10);
                                var9.updateCount = var1;
                                ++var6;
                            }
                        }

                        var9.clearedCount = var1;
                    }
                }
            }
        }
    }

    return var6;
}

 

 

 

private int updateSelectedKeys() {
    ++this.updateCount;
    byte var1 = 0;
    int var4 = var1 + this.subSelector.processSelectedKeys(this.updateCount);

    WindowsSelectorImpl.SelectThread var3;
    for(Iterator var2 = this.threads.iterator(); var2.hasNext(); var4 += var3.subSelector.processSelectedKeys(this.updateCount)) {
        var3 = (WindowsSelectorImpl.SelectThread)var2.next();
    }

    return var4;
}

 

这里，将会在所有线程中调用processSelectedKeys()来对所有线程在poll过程中取得的结果进行处理，并返回所有线程中处理的channel的数量。

 

private int processSelectedKeys(long var1) {
    byte var3 = 0;
    int var4 = var3 + this.processFDSet(var1, this.readFds, 1, false);
    var4 += this.processFDSet(var1, this.writeFds, 6, false);
    var4 += this.processFDSet(var1, this.exceptFds, 7, true);
    return var4;
}

private int processFDSet(long var1, int[] var3, int var4, boolean var5) {
    int var6 = 0;

    for(int var7 = 1; var7 <= var3[0]; ++var7) {
        int var8 = var3[var7];
        if(var8 == WindowsSelectorImpl.this.wakeupSourceFd) {
            synchronized(WindowsSelectorImpl.this.interruptLock) {
                WindowsSelectorImpl.this.interruptTriggered = true;
            }
        } else {
            WindowsSelectorImpl.MapEntry var9 = WindowsSelectorImpl.this.fdMap.get(var8);
            if(var9 != null) {
                SelectionKeyImpl var10 = var9.ski;
                if(!var5 || !(var10.channel() instanceof SocketChannelImpl) || !WindowsSelectorImpl.this.discardUrgentData(var8)) {
                    if(WindowsSelectorImpl.this.selectedKeys.contains(var10)) {
                        if(var9.clearedCount != var1) {
                            if(var10.channel.translateAndSetReadyOps(var4, var10) && var9.updateCount != var1) {
                                var9.updateCount = var1;
                                ++var6;
                            }
                        } else if(var10.channel.translateAndUpdateReadyOps(var4, var10) && var9.updateCount != var1) {
                            var9.updateCount = var1;
                            ++var6;
                        }

                        var9.clearedCount = var1;
                    } else {
                        if(var9.clearedCount != var1) {
                            var10.channel.translateAndSetReadyOps(var4, var10);
                            if((var10.nioReadyOps() & var10.nioInterestOps()) != 0) {
                                WindowsSelectorImpl.this.selectedKeys.add(var10);
                                var9.updateCount = var1;
                                ++var6;
                            }
                        } else {
                            var10.channel.translateAndUpdateReadyOps(var4, var10);
                            if((var10.nioReadyOps() & var10.nioInterestOps()) != 0) {
                                WindowsSelectorImpl.this.selectedKeys.add(var10);
                                var9.updateCount = var1;
                                ++var6;
                            }
                        }

                        var9.clearedCount = var1;
                    }
                }
            }
        }
    }

    return var6;
}

 

 

 

这里实则是对在之前的监听到发生了io时间需要处理的fd与对应的channel进行操作，根据读到的fd取得selector下注册了的相应的channel，根据监听到其所发生的时间类型（读，写，异常）更新channel应有的状态，这是其主要功能，在完成这些操作之后，相应的slector的select也相应完成。

BIO/NIO/多路复用/Selector/select/poll/epoll
Apollo的博客
03-27 2056
前言 进行总结的初衷是没搞明白linux下的select/poll/epoll与java下nio的selector多路复用器的关系，于是对知识点进行了梳理。 先上结论，selector多路复用器算是对linux下的select/poll/epoll进行封装，selector可以i有多种实现，linux系统下默认使用epoll的实现方式。 BIO模型 https://www.jianshu.com/p/138847d5cafd BIO即为阻塞IO的意思，通常我们讲BIO的时候都会和服务器模型配合着讲，在实际应
【Java硬核知识：IO/NIO核心原理与性能压榨】Selector空轮询Bug：Netty是如何彻底解决的？
专注于人工智能、软件开发、工控自动化、工厂数字化及智能化等领域，希望和大家共同进步！
04-18 973
摘要：本文围绕 Java NIO 中 Selector 空轮询 Bug 展开，先回顾 NIO 基础与 Selector 工作原理，剖析空轮询触发条件，包括网络、系统、并发及 JDK 版本等因素。接着阐述 Netty 的 rebuildSelector 策略，通过检测空轮询后重建 Selector 解决问题，并分析其优缺点。同时介绍 select、poll 和 epoll 原理，说明 Java 中使用 epoll 的方法与优势。最后通过实操案例，展示基于 Netty 和 epoll 构建高性能网络服务器的过程
jdk的selector(1)
不说话装高手
01-14 327
在java中如过需要用到Selector来处理Nio的情况下，需要先使用SelectorProvider的provider()方法来取得相应的SelectorProvider。   public static SelectorProvider provider() { synchronized (lock) { if (provider != null) ...
jdk的Selector源码分析（一）Selector概述
weixin_34327223的博客
08-16 223
2019独角兽企业重金招聘Python工程师标准>>> ...
jdk的nio之selector（1）
panxj856856的博客
05-22 419
看了netty源码后发现，它不过是封装在jdk的nio之上的框架，虽然大致猜到nio的原理，但还是忍不住要去jdk底层一探究竟。要用selector，第一句话无非Selector selector = Selector.open();但里面如何实现的？ public static Selector open() throws IOException { return Sele...
jdk源码解析八之NIO(selector)
Nuan_Feng的博客
08-14 223
这里写自定义目录标题示例代码register 示例代码 ServerSocketChannel serverChannel = ServerSocketChannel.open(); ServerSocket serverSocket = serverChannel.socket(); Selector selector = Selector.open(); serverSocket.bind (new InetSocketAddress (port)); serverChannel.con
并发编程之Java中Selector
pleaseprintf的博客
04-08 926
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通用，看懂了就去分享给你的码吧。Selector提供选择执行已经就绪的任务的能力，使得多元 I/O 成为可能，就绪选择和多元执行使得单线程能够有效率地同时管理多个 I/O channel。C/C++许多年前就已经有 select()和 poll()这两个POSIX（可移植性操作系统接口）系统调用可供使用。
Selector.select() returnd prematurely 512 times
07-27
首先，用户的问题是：“我想解决Java NIO中Selector.select()方法提前返回的问题 请问Java NIO Selector.select() returned prematurely 512 times fix”。这是关于Java NIO的Selector.select()方法在未准备好通道时...
Selector.select() returnd prematurely 512 times in a row
最新发布
07-27
</think>Java NIO 中的 `Selector.select()` 方法在无事件时提前返回（空轮询）并连续发生 512 次，是著名的 **JDK epoll 空轮询 Bug** 的表现。这会导致 CPU 占用率飙升至 100%，严重影响系统性能。以下是详细分析...
Netty selector的运行
qq_44587855的博客
07-27 565
终于Selector要开始工作了。 NioEventLoop#select private void select(boolean oldWakenUp) throws IOException { //拿到selector Selector selector = this.selector; try { int selectCnt = 0; long currentTimeNanos = System.nan..
select()函数
06-25 555
习惯写诸如connect、 accept、recv或recvfrom这样的阻塞程序（所谓阻塞方式block，顾名思义，就是进程或是线程执行到这些函数时必须等待某个事件的发生，如果事件没有发生，进程或线程就被阻塞，函数不能立即返回）。 可是使用Select就可以完成非阻塞（所谓非阻塞方式non-block，就是进程或线程执行此函数时不必非要 等待事件的发生，一旦执行肯定返回，以返回值的不同来反映
jdk源码分析 ——Selector深入分析
m47838704的专栏
01-20 485
1、spi方式的selector定制化 selector通过SelectorProvider创建的，通常不同安装版本的jdk中已经封装了相应的Select和SelectorProvider了，通过spi的方式进行扩展。（PS：spi是一种jdk提供的低侵入方式的扩展实现，目前已经在大多数的框架中使用了，类似dubbo框架也使用该方式，让用户进行更好的定制化实现） 2、selector的原理
jdk的nio之selector（2）
panxj856856的博客
05-23 399
上篇博文分析了selector的建立，在这之后selector跟ServerSocketChannel，SocketChannel配合使用，在这里我将会介绍在selector.open()；之后，我们以服务器端为切入点，重点关注下面两个方法的实现 ServerSocketChannel serverSocketChannel = ServerSocketChannel.ope...
NIO空轮训
weixin_39312465的博客
04-19 277
转载：https://www.jianshu.com/p/3ec120ca46b2
NIO this.selector.select()
qq_44587855的博客
07-26 609
重点：最后执行SelectorImpl.doSelect，在windows平台由WindowsSelectorImpl实现 一个个来分析
NIO源码阅读笔记 select方法（三）
xxy_hl的博客
08-18 478
select方法的实现在SelectorImpl类中，有两种实现方式，无参的和单参的，无参方法直接调用单参方法，默认传入0： public int select(long var1) throws IOException { if (var1 < 0L) { throw new IllegalArgumentException("Negative t...
Java线程泄露的分析与处理
weixin_33725126的博客
04-27 482
1. 生产环境的异常现象及初步分析最近发现系统程序内存消耗越来越大，开始并没特别注意，就简单调了一下jvm参数。但直到前些天内存爆满，持续Full GC，这肯定出现了内存泄露。原以为哪里出现了比较低级的错误，所以很直接想到先去看看程序是在跑哪段代码。jstack -l <pid>以后，居然有上千个线程，而且都是属于RUNNING并WAIT的状态。I/Odispa...
网络编程IO多路复用
爪哇岛咖啡种植农场
05-08 418
简单聊聊Java提供的IO多路复用
JAVA NIO源码分析之Selector
qq_35368651的博客
09-02 794
      先上一段代码 public static void main(String[] args) throws Exception{ Selector selector = SelectorProvider.provider().openSelector(); ServerSocketChannel serverSocketChannel = Serv...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值