Netty-选择器-监听

于 2024-05-28 17:13:12 发布
阅读量342 收藏 4
点赞数 8
分类专栏： 源码 文章标签： java Netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fl_zxf/article/details/139272564
版权

归档

介绍

  • 参考 NioEventLoop
  • 主要逻辑为：死循环监听 selector
  • 总结：
    • 创建的线程是 FastThreadLocalThread 实例

原理

  • io.netty.channel.nio.NioEventLoop
/*** NIO 事件轮循 */
public final class NioEventLoop extends SingleThreadEventLoop {
    private Selector selector;              // 封装的选择器。可参考：#openSelector()
    private Selector unwrappedSelector;     // JDK 底层选择器
    private SelectedSelectionKeySet selectedKeys;
    private final SelectorProvider provider;// 选择器 SPI 提供者

    /*** sign_m_511 钩子函数（任务逻辑），可理解为线程的 Runnable #run() 方法 */
    @Override
    protected void run() {
        for (;;) { // 死循环监听
            try {
                int strategy;
                try {
                    strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
                    switch (strategy) {
                    ... // 省略其他 case
                    case SelectStrategy.SELECT:
                        long curDeadlineNanos = ... // 一般设置为 NONE
                        ...
                        try {
                            if (!hasTasks()) {
                                strategy = select(curDeadlineNanos); // select 监听
                            }
                        } ... // finally
                    default:
                    }
                } catch (IOException e) {
                    rebuildSelector0(); // 有错误，重新构建选择器并将信道注册进去
                    ...
                    continue;
                }

                ...

                if (ioRatio == 100) {
                    ...
                } else if (strategy > 0) {
                    try {
                        processSelectedKeys(); // 处理 keys
                    } ... // finally
                } else {
                    ranTasks = runAllTasks(0); // 运行队列中所有积压的任务
                }

                ...
            } ... // catch finally
        }
    }

    /*** 监听 */
    private int select(long deadlineNanos) throws IOException {
        if (deadlineNanos == NONE) {
            return selector.select(); // 相当于底层监听
        }
        long timeoutMillis = deadlineToDelayNanos(deadlineNanos + 995000L) / 1000000L;
        return timeoutMillis <= 0 ? selector.selectNow() : selector.select(timeoutMillis); // 限时监听
    }

    /*** 处理 keys */
    private void processSelectedKeys() {
        if (selectedKeys != null) {
            processSelectedKeysOptimized();
        } else {
            processSelectedKeysPlain(selector.selectedKeys()); // 处理 keys
        }
    }
    
    /*** 处理 keys */
    private void processSelectedKeysPlain(Set<SelectionKey> selectedKeys) {
        ... // 校验空

        Iterator<SelectionKey> i = selectedKeys.iterator();
        for (;;) {
            final SelectionKey k = i.next();
            final Object a = k.attachment();
            i.remove(); // 需要移除（可参考 JDK-示例）

            if (a instanceof AbstractNioChannel) {
                processSelectedKey(k, (AbstractNioChannel) a); // 处理单个 key
            } ... // else

            ... // 没有下一项，退出循环
            ... // needsToSelectAgain(再次选择)处理
        }
    }

    /*** 处理单个 key */
    private void processSelectedKey(SelectionKey k, AbstractNioChannel ch) {
        final AbstractNioChannel.NioUnsafe unsafe = ch.unsafe();
        ... // key 无效处理

        try {
            int readyOps = k.readyOps();
            if ((readyOps & SelectionKey.OP_CONNECT) != 0) { // 客户端连接事件
                int ops = k.interestOps();
                ops &= ~SelectionKey.OP_CONNECT;
                k.interestOps(ops);     // 重置 key 的兴趣事件
                unsafe.finishConnect(); // 相当于 sc.finishConnect()，等待连接完成
            }
            if ((readyOps & SelectionKey.OP_WRITE) != 0) { // 写事件
                unsafe.forceFlush();    // sign_o_001 出站处理（但测试时但没调用过）
            }
            if ((readyOps & (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) { // 读事件、接收连接事件
                unsafe.read();          // sign_o_002 入站处理
            }
        } ... // catch 
    }
}

启动线程

  • 继续上面 NioEventLoop 原理介绍

    • 流程：调用 execute(Runnable) 执行任务时，若没有线程，则会启动线程并绑定

  • 默认其实例变量 thread(io.netty.util.concurrent.SingleThreadEventExecutor #thread) 为 null

    • 方法 inEventLoop(curThread) 会返回 false

  • io.netty.util.concurrent.SingleThreadEventExecutor

/*** 单线程-执行器 */
public abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
    
    private final Executor executor;

    /*** 执行任务 */
    @Override
    public void execute(Runnable task) {
        execute0(task);
    }

    private void execute0(@Schedule Runnable task) {
        ObjectUtil.checkNotNull(task, "task");
        execute(task, wakesUpForTask(task)); // sign_m_101
    }

    protected boolean wakesUpForTask(Runnable task) {
        return true; // 直接返回 true，表示立即执行
    }

    // sign_m_121
    @Override
    public boolean inEventLoop(Thread thread) {
        return thread == this.thread; // 第一次执行 this.thread 为 null，所有返回 false
    }

    // sign_m_101 执行任务
    private void execute(Runnable task, boolean immediate) {
        boolean inEventLoop = inEventLoop(); // sign_m_120 第一次执行时，返回 false
        addTask(task); // 添加到队列
        if (!inEventLoop) {
            startThread(); // 启动线程
            ... // 省略停机判断和拒绝处理
        }

        if (!addTaskWakesUp && immediate) {
            wakeup(inEventLoop);
        }
    }

    // 启动线程
    private void startThread() {
        if (state == ST_NOT_STARTED) {
            if (STATE_UPDATER.compareAndSet(this, ST_NOT_STARTED, ST_STARTED)) { // CAS 改状态
                boolean success = false;
                try {
                    doStartThread(); // 启动线程
                    success = true;
                } ... // finally
            }
        }
    }

    // 启动线程
    private void doStartThread() {
        assert thread == null;
        /**
         * sign_m_501 创建线程并执行任务
         * 
         * executor 为 ThreadPerTaskExecutor 实例
         *   executor.execute() 会创建新线程
         *   executor 设值参考 #executor-设值
         */
        executor.execute(new Runnable() {
            @Override
            public void run() {
                thread = Thread.currentThread(); // 给 this.thread 设值

                try {
                    SingleThreadEventExecutor.this.run(); // sign_m_511 调用钩子函数 run（子类实现具体的逻辑）
                } catch (Throwable t) {
                    logger.warn("Unexpected exception from an event executor: ", t);
                } finally {
                    ... // 省略停机(Shutdown)处理
                }
            }
        });
    }

    /*** 构造器 */
    protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor, ...) {
        ...
        this.executor = ThreadExecutorMap.apply(executor, this); // sign_m_301 封装 executor
        ...
    }
}
  • io.netty.util.concurrent.AbstractEventExecutor
/*** 抽象事件执行器 */
public abstract class AbstractEventExecutor extends AbstractExecutorService implements EventExecutor {
    // sign_m_120 判断是不是在当前线程中执行新任务
    @Override
    public boolean inEventLoop() {
        return inEventLoop(Thread.currentThread()); // sign_m_121 用当前线程判断
    }
}
  • io.netty.util.internal.ThreadExecutorMap
/**
 * 线程执行器映射。
 * 用于获取调用线程的 EventExecutor
 */
public final class ThreadExecutorMap {
    /*** sign_m_301 封装 executor */
    public static Executor apply(final Executor executor, final EventExecutor eventExecutor) {
        ... // 校验
        return new Executor() { // 封装
            @Override
            public void execute(final Runnable command) {
                executor.execute(apply(command, eventExecutor)); // sign_m_302 封装 command
            }
        };
    }

    /*** sign_m_302 封装 command */
    public static Runnable apply(final Runnable command, final EventExecutor eventExecutor) {
        ... // 校验
        return new Runnable() {
            @Override
            public void run() {
                setCurrentEventExecutor(eventExecutor);
                try {
                    command.run();
                } finally {
                    setCurrentEventExecutor(null);
                }
            }
        };
    }
}
  • io.netty.util.concurrent.ThreadPerTaskExecutor
/*** 每任务一线程执行器 */
public final class ThreadPerTaskExecutor implements Executor {
    private final ThreadFactory threadFactory; // 线程工厂

    public ThreadPerTaskExecutor(ThreadFactory threadFactory) {
        this.threadFactory = ObjectUtil.checkNotNull(threadFactory, "threadFactory");
    }

    // sign_m_501 创建线程并执行任务
    @Override
    public void execute(Runnable command) {
        /**
         * sign_m_601 创建线程
         * ------------------
         * 并启动线程。
         */
        threadFactory.newThread(command).start();
    }
}
executor-设值
  • io.netty.channel.nio.NioEventLoopGroup
// NIO 事件轮循组
public class NioEventLoopGroup extends MultithreadEventLoopGroup {
    /*** 构造器 */
    public NioEventLoopGroup(int nThreads) {
        this(nThreads, (Executor) null); // sign_m_401 executor 一直传 null 过去
    }

    // sign_m_401
    public NioEventLoopGroup(int nThreads, Executor executor) {
        this(nThreads, executor, SelectorProvider.provider()); // sign_m_402
    }

    // sign_m_402
    public NioEventLoopGroup(
            int nThreads, Executor executor, final SelectorProvider selectorProvider) {
        this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE); // sign_m_403
    }

    // sign_m_403
    public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                             final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject()); // sign_m_411
    }

    /**
     * sign_m_4c1 创建子线程（钩子函数）
     * executor 一般是 ThreadPerTaskExecutor 实例
     */
    @Override
    protected EventLoop newChild(Executor executor, Object... args) throws Exception {
        ... // 省略构造参数设置逻辑
        return new NioEventLoop(this, executor, selectorProvider,
                selectStrategyFactory.newSelectStrategy(),
                rejectedExecutionHandler, taskQueueFactory, tailTaskQueueFactory);
    }
}
  • io.netty.channel.MultithreadEventLoopGroup
// 多线程事件轮循
public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {
    // sign_m_411 构造器
    protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
        /**
         * nThreads 为 0，则默认用 cpus * 2
         */
        super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args); // sign_m_421
    }
}
  • io.netty.util.concurrent.MultithreadEventExecutorGroup
/*** 多线程事件执行组 */
public abstract class MultithreadEventExecutorGroup extends AbstractEventExecutorGroup {
    // sign_m_421
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
        this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args); // sign_m_422
    }

    // sign_m_422
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args
    ) {
        /**
         * executor 传值一直为 null，所以默认使用 ThreadPerTaskExecutor 实例
         */
        if (executor == null) {
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }

        children = new EventExecutor[nThreads]; // 根据线程数创建数组

        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                /**
                 * sign_m_4c1 创建子线程（钩子函数）
                 * executor 传上面创建的 ThreadPerTaskExecutor 实例
                 */
                children[i] = newChild(executor, args);
                success = true;
            } catch (Exception e) {
                throw new IllegalStateException("failed to create a child event loop", e);
            } finally {
                ... // 未成功创建子线程的处理 (success = false)
            }
        }

        chooser = chooserFactory.newChooser(children); // 选取器（轮循选择下一个子线程）

        ... // 省略事件监控处理
    }

    // 创建默认线程工厂
    protected ThreadFactory newDefaultThreadFactory() {
        return new DefaultThreadFactory(getClass());
    }
}
  • io.netty.util.concurrent.DefaultThreadFactory
// 默认线程工厂
public class DefaultThreadFactory implements ThreadFactory {

    // sign_m_601 创建线程
    @Override
    public Thread newThread(Runnable r) {
        Thread t = newThread(FastThreadLocalRunnable.wrap(r), prefix + nextId.incrementAndGet());
        ... // 省略守护和优先级设置
        return t;
    }

    // 创建 FastThreadLocalThread 实例
    protected Thread newThread(Runnable r, String name) {
        return new FastThreadLocalThread(threadGroup, r, name);
    }
}
【Netty系列】NIO编程案例（Selector）
Love Peace
04-26 568
Java的NIO，用非阻塞的IO方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector（选择器）。Selector 能够检测多个注册的通道上是否有事件发生（注意：多个Channel以事件的方式可以注册到同一个Selector），如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。只有在连接/通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程。
Netty - Socket.io
最新发布
aRtHuR1207的博客
09-25 3141
注意，这里存在一个关键点：需要设置自定义存储工厂，以便获取 AuthorizationResult 中的 storeParams。在本示例中，我们采用 Redisson 作为存储工厂。修改nacos配置socketio:# redis服务redis:sentinel:更新socketio启动配置类/***/@Slf4j@Autowired@Autowired@Autowired@Autowired@Autowired。
Netty-监听读写事件
weixin_42002747的博客
09-26 787
前言：监听读写事件是对于NioSocketChannel来说的，而NioSocketChannel和NioServerSocketChannel都对应NioEventLoop 1、看NioEventLoop线程的loop方法，NioEventLoop的run()方法 2、 3、 4、 5、 6、 最后：6就是NioSocketChannel每次监听读事件的地方，随后会调用响应的pipeline。 ...
手撕netty源码（四）- ServerBootstrap是如何监听事件的
qq_32139981的博客
04-29 850
本篇从源码讲解 ServerBootstrap 是如何监听各种事件的。netty的服务端源码讲解已经接近尾声，但是每一块都比较散，没有将整体串起来，下一篇我会把整个netty服务端的线程模型和逻辑架构串起来，对整体有个清晰的认识。
netty源码分析(十六)Channel选择器工厂与轮询算法及注册底层实现
wzq6578702的专栏
11-05 1449
上一节说到注册的入口，即 MultithreadEventLoopGroup: public ChannelFuture register(Channel channel) { return next().register(channel); }注册channel第一步调用了next()方法，next()是MultithreadEventLoopGroup里边的:
Netty学习笔记 3.8 选择器
zyzy123321的博客
07-26 331
Netty学习笔记 3.8 选择器 Selector(选择器) 基本介绍 Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector(选择器) Selector 能够检测多个注册的通道上是否有事件发生(注意:多个Channel以事件的方式可以注册到同一个Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。【示意图】 只有在 连接/通道 真正有读写事件发生时，才会进行
Netty-讲义.zip
10-09
NIO 相比传统的 IO，提供了选择器（Selector）和通道（Channel）等机制，允许在一个线程中处理多个连接，从而提高了服务器的并发能力。文件可能会介绍如何在 Netty 中使用 Selectors 监听多个 Channel 的事件，以及...
netty-api-4.1 中文版
06-03
在使用 Netty API 4.1 的过程中，开发者可以利用 ChannelFuture 和 Promise 来异步地处理网络操作，它们代表了未来的操作结果，可以注册监听器来获取操作完成的通知。同时，Netty 提供了丰富的工具类，如 ByteBuf，...
netty-cookbook
06-13
- **性能优化**：提供优化 Netty 应用性能的技巧，例如内存池的使用、线程模型的选择等。 - **安全性配置**：演示如何实现 SSL/TLS 安全通信，保护数据传输的安全。 - **协议实现**：可能包括 HTTP、FTP、SMTP 等...
netty-workspace:netty使用示例，netty原始阅读
03-24
Netty 使用 Java NIO 库，通过选择器（Selector）来高效地处理多个连接。它还利用了内存池来减少对象创建的开销，提高性能。 标签中的“系统开源”表明这是一个开放源代码的项目，这意味着你可以自由地查看、学习和...
Netty源码阅读（五）：选择器
scofen的博客
03-18 316
选择器 最后，我们探索一下选择器。由于选择器内容比较多，所以本篇先偏理论地讲一下，后一篇讲代码，文章也没有什么概括、总结的，写到哪儿算哪儿了，只求能将选择器写明白，并且将一些相对重要的内容加粗标红。 选择器提供选择执行已经就绪的任务的能力，这使得多元I/O成为了可能，就绪执行和多元选择使得单线程能够有效地同时管理多个I/O通道。 某种程度上来说，理解选择器比理解缓冲区和通道类更困难一些和复杂...
《netty》javaNIO之Selector（选择器）介绍
kaige8312的博客
11-21 1114
Selector（选择器）介绍 Selector 一般称 为选择器 ，当然你也可以翻译为 多路复用器 。它是Java NIO核心组件中的一个，用于检查一个或多个NIO Channel（通道）的状态是否处于可读、可写。如此可以实现单线程管理多个channels,也就是可以管理多个网络链接。   使用Selector的好处在于： 使用更少的线程来就可以来处理通道了， 相比使用多个线程，避免了...
netty-注册执行器选择
godme
03-18 280
线程再定义 线程原意 百度百科 ： 一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务 偏颇和漏洞 实话说来，上面的定义没有问题，但是本质不够明确，它说了这几点 单一顺序控制流 并发 执行任务 但是结合自身的体会，我发现线程这个概念在我的思想里总是不固定，越是探究，越是多变。 如今，发现了根本问题，我们理解的线程的概念，不过是：并发执行任务的方式。...
Netty：ChannelHandler的两个生命周期监听事件方法：handlerAdded 和 handlerRemoved
听海边涛声
08-09 1139
Netty：ChannelHandler的两个生命周期监听事件方法：handlerAdded 和 handlerRemoved
【5. Netty ChannelFuture 异步监听】
W664160450的博客
03-29 4700
1. 前言 本节主要讲解 ChannelFuture ，它的作用是用来保存 Channel 异步操作的结果，可以看作是一个异步操作结果的占位符。 2. 概念 在 Netty 中所有的 IO 操作都是异步的，不能立刻得到 IO 操作的执行结果，但是可以通过注册一个监听器来监听其执行结果。在 Java 的并发编程当中可以通过 Future 来进行异步结果的监听，但是在 Netty 当中是通过 ChannelFuture 来实现异步结果的监听。通过注册一个监听的方式进行监听，当操作执行成功或者失败时监听会自
（五）Netty之Selector选择器
qq_38949960的博客
01-07 683
基本介绍 Java的NIO，用非阻塞的IO方式，可以用一个线程，处理多个客户端连接，就会使用到Selector（选择器）
Netty事件监听和处理（上）【有福利】
weixin_33777877的博客
04-03 1414
陪产假结束了，今天又开始正常上班了，正好赶上米粉节活动，又要忙上一阵了，米粉节活动时间为4.03 - 4.10，有不少优惠，感兴趣的可以关注mi.com或小米商城app。 今天给大家送了福利：小爱音箱F码，据说卖的比较好，不太好抢到，借着这次公司福利，分享给大家，以表大家的支持和鼓励。 掘金的运营真的很贴心，主动找到我说：我的福利文章不是技术型文章，不能推送到信息流，只能在个人主页看到，为了让更多...
Netty异步模型Future-Listener机制
weixin_44371237的博客
01-09 637
链式处理每一步都有handler进行监听callback或future 服务端代码addListener 其他模块与下列连接一致 https://blog.youkuaiyun.com/weixin_44371237/article/details/122391777?spm=1001.2014.3001.5501 public class Server { public static void main(String[] args) throws InterruptedException { ...
Netty事件监听和处理（下）
weixin_34115824的博客
04-05 884
为什么80%的码农都做不了架构师？>>> ...
netty-socketio实现高效前端实时通信
在该示例项目中，可能会包含如何创建socket事件监听器，如何分发事件给连接的客户端，以及如何处理各种不同类型的连接请求等内容。 7. **文件结构：** 在提供的压缩包中，包含socket.io.min.js和socket.io.js两个...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值