Netty源码解析-NioEventLoop初始化

最新推荐文章于 2022-07-09 23:02:57 发布
最新推荐文章于 2022-07-09 23:02:57 发布
阅读量264 收藏 3
点赞数 2
分类专栏： JAVA 源码解析 netty 文章标签： netty源码解析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ybin__/article/details/81007018
版权
JAVA 同时被 3 个专栏收录
6 篇文章 0 订阅
订阅专栏
源码解析
2 篇文章 0 订阅
订阅专栏
netty
2 篇文章 0 订阅
订阅专栏
本文详细介绍了Netty中NioEventLoop的初始化步骤，包括NioEventLoopGroup的构造过程、线程执行器ThreadPerTaskExecutor的创建、NioEventLoop的选择器优化以及EventExecutorChooser的实现，揭示了Netty如何实现高效异步事件处理。
摘要由CSDN通过智能技术生成

    作为Netty的核心组件之一，NioEventLoop负责处理netty中的各种事件，每个NioEventLoop上有一个selector负责轮询IO事件，有一个定时任务队列及普通任务队列负责处理注册到NioEventLoop上的非IO任务。而1组NioEventLoop右由一个NioEventLoopGroup负责管理，默认一个NioEventLoopGroup管理2倍CPU核数的NioEventLoop。

    参照官网的服务端写法：
    

public void run() {
    EventLoopGroup bossGroup = new NioEventLoopGroup();
    EventLoopGroup workGroup = new NioEventLoopGroup();

    ServerBootstrap b = new ServerBootstrap();
    b.group(bossGroup, workGroup)
            .channel(NioServerSocketChannel.class)
            .option(ChannelOption.SO_BACKLOG, 128)
            .childOption(ChannelOption.SO_KEEPALIVE, true)
            .handler(new ChannelHandler())
            .childHandler(new ChannelInitializer<SocketChannel>() {
                @Override
                protected void initChannel(SocketChannel socketChannel) throws Exception {
                    socketChannel.pipeline().addLast(new ChannelInboundA(), new ChannelInboundB(), new ChannelInboundC());
                }
            });

    try {
        ChannelFuture future = b.bind(port).sync();
        log.info("server start running");
        future.channel().closeFuture().sync();
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        bossGroup.shutdownGracefully();
        workGroup.shutdownGracefully();
    }
}

  1. NioEventLoop实在初始化NioEventLoopGroup的过程中被初始化；
  2. 当NioEventLoopGroup的构造参数不传值时，netty默认会为每个NioEventLoopGroup配置2倍的CPU核数个NioEventLoop：
    static {
        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
                "io.netty.eventLoopThreads", Runtime.getRuntime().availableProcessors() * 2));

        if (logger.isDebugEnabled()) {
            logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
        }
    }
  3. 最终调用到NioEventLoopGroup的父类MultithreadEventExecutorGroup的构造方法：
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    if (nThreads <= 0) {
        throw new IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
    }

    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }

    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            children[i] = newChild(executor, args);
            success = true;
        } catch (Exception e) {
            // TODO: Think about if this is a good exception type
            throw new IllegalStateException("failed to create a child event loop", e);
        } finally {
            if (!success) {
                for (int j = 0; j < i; j ++) {
                    children[j].shutdownGracefully();
                }

                for (int j = 0; j < i; j ++) {
                    EventExecutor e = children[j];
                    try {
                        while (!e.isTerminated()) {
                            e.awaitTermination(Integer.MAX_VALUE, TimeUnit.SECONDS);
                        }
                    } catch (InterruptedException interrupted) {
                        // Let the caller handle the interruption.
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }
        }
    }

    chooser = chooserFactory.newChooser(children);

    final FutureListener<Object> terminationListener = new FutureListener<Object>() {
        @Override
        public void operationComplete(Future<Object> future) throws Exception {
            if (terminatedChildren.incrementAndGet() == children.length) {
                terminationFuture.setSuccess(null);
            }
        }
    };

    for (EventExecutor e: children) {
        e.terminationFuture().addListener(terminationListener);
    }

    Set<EventExecutor> childrenSet = new LinkedHashSet<EventExecutor>(children.length);
    Collections.addAll(childrenSet, children);
    readonlyChildren = Collections.unmodifiableSet(childrenSet);
}
  4. 在该构造方法中主要做了3件事：
    1).创建一个线程执行器ThreadPerTaskExecutor，以便于后续NioEventLoop在处理task任务时，可直接调用io.netty.util.concurrent.ThreadPerTaskExecutor#execute该方法启动线程，异步执行任务。
    2).为NioEventLoopGroup创建EventExecutor数组，及NioEventLoop数组。
    3).为NioEventLoopGroup创建一个NioEventLoop旋转器，负责有事件事从NioEventLoop数组中选择NioEventLoop来执行任务。
  5. 创建ThreadPerTaskExecutor：
    1).
    executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    2).调用newDefaultThreadFactory()设置NioEventLoop线程标识前缀：
    public DefaultThreadFactory(String poolName, boolean daemon, int priority, ThreadGroup threadGroup) {
    if (poolName == null) {
        throw new NullPointerException("poolName");
    }
    if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
        throw new IllegalArgumentException(
                "priority: " + priority + " (expected: Thread.MIN_PRIORITY <= priority <= Thread.MAX_PRIORITY)");
    }

    prefix = poolName + '-' + poolId.incrementAndGet() + '-';
    this.daemon = daemon;
    this.priority = priority;
    this.threadGroup = threadGroup;
}
    其中poolName为nioEventLoopGroup，可以看到线程的前缀为nioEventLoopGroup-自增id-；
  6. NioEventLoopGroup轮询创建NioEventLoop线程组：
    1).调用NioEventLoopGroup的newChild方法：
    protected EventLoop newChild(Executor executor, Object... args) throws Exception {
    return new NioEventLoop(this, executor, (SelectorProvider) args[0],
        ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2]);
}
    2).进入NioEventLoop的构造：
    NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
             SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler) {
    super(parent, executor, false, DEFAULT_MAX_PENDING_TASKS, rejectedExecutionHandler);
    if (selectorProvider == null) {
        throw new NullPointerException("selectorProvider");
    }
    if (strategy == null) {
        throw new NullPointerException("selectStrategy");
    }
    provider = selectorProvider;
    selector = openSelector();
    selectStrategy = strategy;
}
    a.首先调用父类构造保存线程执行器，创建taskQueue有界阻塞队列：
    protected SingleThreadEventExecutor(EventExecutorGroup parent, Executor executor,
                                    boolean addTaskWakesUp, int maxPendingTasks,
                                    RejectedExecutionHandler rejectedHandler) {
    super(parent);
    this.addTaskWakesUp = addTaskWakesUp;
    this.maxPendingTasks = Math.max(16, maxPendingTasks);
    this.executor = ObjectUtil.checkNotNull(executor, "executor");
    taskQueue = newTaskQueue(this.maxPendingTasks);
    rejectedExecutionHandler = ObjectUtil.checkNotNull(rejectedHandler, "rejectedHandler");
}
    b.父类构造执行结束后，再保存selectorProvider，和selectStrategy。
    c.为新创建的NioEventLoop创建一个selector：
    private Selector openSelector() {
    final Selector selector;
    try {
        selector = provider.openSelector();
    } catch (IOException e) {
        throw new ChannelException("failed to open a new selector", e);
    }

    if (DISABLE_KEYSET_OPTIMIZATION) {
        return selector;
    }

    final SelectedSelectionKeySet selectedKeySet = new SelectedSelectionKeySet();

    Object maybeSelectorImplClass = AccessController.doPrivileged(new PrivilegedAction<Object>() {
        @Override
        public Object run() {
            try {
                return Class.forName(
                        "sun.nio.ch.SelectorImpl",
                        false,
                        PlatformDependent.getSystemClassLoader());
            } catch (ClassNotFoundException e) {
                return e;
            } catch (SecurityException e) {
                return e;
            }
        }
    });

    if (!(maybeSelectorImplClass instanceof Class) ||
            // ensure the current selector implementation is what we can instrument.
            !((Class<?>) maybeSelectorImplClass).isAssignableFrom(selector.getClass())) {
        if (maybeSelectorImplClass instanceof Exception) {
            Exception e = (Exception) maybeSelectorImplClass;
            logger.trace("failed to instrument a special java.util.Set into: {}", selector, e);
        }
        return selector;
    }

    final Class<?> selectorImplClass = (Class<?>) maybeSelectorImplClass;

    Object maybeException = AccessController.doPrivileged(new PrivilegedAction<Object>() {
        @Override
        public Object run() {
            try {
                Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
                Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");

                selectedKeysField.setAccessible(true);
                publicSelectedKeysField.setAccessible(true);

                selectedKeysField.set(selector, selectedKeySet);
                publicSelectedKeysField.set(selector, selectedKeySet);
                return null;
            } catch (NoSuchFieldException e) {
                return e;
            } catch (IllegalAccessException e) {
                return e;
            } catch (RuntimeException e) {
                // JDK 9 can throw an inaccessible object exception here; since Netty compiles
                // against JDK 7 and this exception was only added in JDK 9, we have to weakly
                // check the type
                if ("java.lang.reflect.InaccessibleObjectException".equals(e.getClass().getName())) {
                    return e;
                } else {
                    throw e;
                }
            }
        }
    });

    if (maybeException instanceof Exception) {
        selectedKeys = null;
        Exception e = (Exception) maybeException;
        logger.trace("failed to instrument a special java.util.Set into: {}", selector, e);
    } else {
        selectedKeys = selectedKeySet;
        logger.trace("instrumented a special java.util.Set into: {}", selector);
    }

    return selector;
}
        再创建NioEventLoop的selector时，Netty除了调用JDK创建Selector外，还会将sun.nio.ch.SelectorImpl中保存SelectionKey的set集合利用反射用数组 SelectedSelectionKeySet替换掉该set集。
    Field selectedKeysField = selectorImplClass.getDeclaredField("selectedKeys");
Field publicSelectedKeysField = selectorImplClass.getDeclaredField("publicSelectedKeys");

selectedKeysField.setAccessible(true);
publicSelectedKeysField.setAccessible(true);

selectedKeysField.set(selector, selectedKeySet);
publicSelectedKeysField.set(selector, selectedKeySet);
    SelectedSelectionKeySet添加SelectionKey时是直接在数组的最后有值位后添加，相比于set集合的add时间复杂度为O(1)，SelectedSelectionKeySet的效率更高。
    @Override
public boolean add(SelectionKey o) {
    if (o == null) {
        return false;
    }

    if (isA) {
        int size = keysASize;
        keysA[size ++] = o;
        keysASize = size;
        if (size == keysA.length) {
            doubleCapacityA();
        }
    } else {
        int size = keysBSize;
        keysB[size ++] = o;
        keysBSize = size;
        if (size == keysB.length) {
            doubleCapacityB();
        }
    }

    return true;
}        
  7. 创建NioEventLoop旋转器：
    public EventExecutorChooser newChooser(EventExecutor[] executors) {
    if (isPowerOfTwo(executors.length)) {
        return new PowerOfTowEventExecutorChooser(executors);
    } else {
        return new GenericEventExecutorChooser(executors);
    }
    1).首选调用isPowerOfTwo(int val)判断NioEventLoopGroup的NioEventLoop线程组是否是2的幂:
    private static boolean isPowerOfTwo(int val) {
    return (val & -val) == val;
}
    2).如果是2的幂执行PowerOfTowEventExecutorChooser的构造：
    private static final class PowerOfTowEventExecutorChooser implements EventExecutorChooser {
    private final AtomicInteger idx = new AtomicInteger();
    private final EventExecutor[] executors;

    PowerOfTowEventExecutorChooser(EventExecutor[] executors) {
        this.executors = executors;
    }

    @Override
    public EventExecutor next() {
        return executors[idx.getAndIncrement() & executors.length - 1];
    }
}
            PowerOfTowEventExecutorChooser的构造保存NioEventLoop线程组，该类中还有一个next()方法，即是在有事件分配NioEventLoop时调用，下标是每次自增前&上线程数组的长度减1，利用机器码快速选择NioEventLoop；
    3).如果不是2的幂：
    private static final class GenericEventExecutorChooser implements EventExecutorChooser {
    private final AtomicInteger idx = new AtomicInteger();
    private final EventExecutor[] executors;

    GenericEventExecutorChooser(EventExecutor[] executors) {
        this.executors = executors;
    }

    @Override
    public EventExecutor next() {
        return executors[Math.abs(idx.getAndIncrement() % executors.length)];
    }
}
            netty在不是2的幂时，分配NioEventLoop，调用next()获取NioEventLoop是自增前的值与线程组长度取余。
            显然与运算的效率要高于求余运算，可见Netty为了效率简直丧心病狂了。。。
  8. 整个NioEventLoop初始化流程就是这些了。Netty既是采用这种主从多线程模型实现高效的异步处理事件。服务端启动两个NioEventLoopGroup，一个boss，一个work，boss负责接受请求分发任务，work负责异步处理任务。boss和work下又有多个 NioEventLoop具体来做事。
ybin__
关注
专栏目录
Netty源码分析----NioEventLoop之初始化过程及线程模型
菜鸟一名
06-11 345
Netty的线程模式网上很多文章都有介绍了，很多文章写得也好，加上我的表达能力不太好，这块线程模型的就不分析了，这篇文章主要讲一下Netty线程模型底层实现的细节。 线程线程，肯定就是有线程去处理的，但是Netty的线程不是简简单单用一个Thread或者ThreadPool是去实现那样的一个线程模型，其核心是一个叫做EventLoop的东西，这个可以看成是一个Thread的封装、抽象，以NIO为...
netty 旷视科技_Netty中NioEventLoop源码分析
weixin_31312621的博客
01-28 167
准备赶趟上春招实习的车，刚开始学netty，感觉项目很简单，所以就想看看源码，非科班看这些是真吃力。。放点小笔记，都是站在巨人的肩膀上总结的(小抄)，加油！前置芝士：需要知道Executor执行器的一些操作。Demopublic class NettyServer {int port;public NettyServer(int port) {this.port = port;}public vo...
netty源码--NioEventLoopGroup的初始化
qq_41868309的博客
07-09 341
关于netty源码知识分享
Netty源码分析-NioEventLoopGroup初始化
G-Lawliet的博客
05-10 292
public class GateServer{ private static int port = 9090; public static void main(String[] args) { //配置服务端的NIO线程组 EventLoopGroup bossGroup = new NioEventLoopGroup(); Ev...
【Netty源码解析】NioEventLoop
井底之蛙
11-07 2325
上一篇博客【Netty源码学习】EventLoopGroup中我们介绍了EventLoopGroup，实际说来EventLoopGroup是EventLoop的一个集合，EventLoop是一个单线程的线程池，其接口和类实现关系如下：接下来我们主要介绍实现类NioEventLoop中实现的操作,通过NioEventLoop的继承关系图我们可以看到，其就是一个单线程的线程池。首先我们看NioEven
Netty源码解析-NioEventLoop
业精于勤荒于嬉 行成于思毁于随
12-17 513
一：NioEventLoop的创建 NioEventLoop是由NioEventLoopGroup管理，所以创建操作要去NioEventLoopGroup找，如客户端代码中会先创建NioEventLoopGroup对象，从其构造函数入手，如你调用其无参构造器，一步步往下最终来到 public NioEventLoopGroup(int nThreads, Executor executor...
Netty源码解析-NioEventLoop(二)
业精于勤荒于嬉 行成于思毁于随
12-17 219
Netty源码4.1.22 继前一篇，下面该分析processSelectedKeys() processSelectedKeys()处理IO事件 private void processSelectedKeys() { if (selectedKeys != null) { processSelectedKeysOptimized(); ...
netty源码解析---bind()
kznsbs的博客
11-18 540
概述 bind()方法用于用于进行端口号的绑定 bind() public ChannelFuture bind(int inetPort) { return bind(new InetSocketAddress(inetPort)); } new InetSocketAddress(inetPort) 里面会将本机的ip和传入的端口封装为InetSocketAddress对象 深挖进入dobind() private ChannelFuture doBind(final SocketAdd
Netty源码解析-ServerBootstrap及初始化服务端启动
ybin__的博客
09-22 870
       在https://blog.csdn.net/ybin__/article/details/81007018 中分析了NioEventGroupLoop的初始化，这一章主要ServerBootstrap的初始化，及Netty服务端的启动。  ServerBootstrap的UML图: ServerBootstrap继承至AbstractBootstrap，ServerBootSt...
netty源码分析8-NioEventLoop-IO事件，IO任务
chenchangqun11的专栏
12-06 233
本文分享内容如下： processSelectedKeysOptimized分析 IO事件执行分析 processSelectedKeysOptimized分析 private void processSelectedKeysOptimized(SelectionKey[] selectedKeys) { for (int i = 0;; i ++) { final SelectionK...
Netty学习笔记通信调度篇：NioEventLoop源码解读
船长
08-12 534
目录 初始化过程 Netty对Selecter的优化 注册channel过程 NioEventLoop的任务处理机制 run 方法实现 select 处理就绪事件 runAllTasks处理非I/O任务。 NioEventLoop 继承于 SingleThreadEventLoop, 而 SingleThreadEventLoop 又继承于 SingleThreadEventEx...
Netty4源码分析-flush
海浪儿
11-06 289
本文为原创，转载请注明出处                                                                                                                    Netty4源码分析-flush Netty的写操作由两个步骤组成： Write:将msg存储到ChannelOutboundBuff...
Netty4源码分析- read
海浪儿
11-07 182
本文为原创，转载请注明出处 Netty4源码分析- read    当selector检测到OP_READ事件时，触发read操作： //NioEventLoop if ((readyOps &amp; (SelectionKey.OP_READ | SelectionKey.OP_ACCEPT)) != 0 || readyOps == 0) { ...
Netty框架源码分析
qq_35306443的博客
04-18 390
官网 官网介绍： Netty是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 Netty是一个NIO客户端服务器框架，支持快速、简单地开发协议服务器和客户端等网络应用程序。它大大简化和 流线网络编程，如TCP和UDP套接字服务器。“快速而简单”并不意味着最终的应用程序会出现可维护性或性能问 题。Netty经过精心设计，积累了许多协议(如FTP、SMTP、H...
Netty系列之源码解析（一）
猿灯塔的博客
04-23 528
今天是猿灯塔“365篇原创计划”第十三篇。 接下来的时间灯塔君持续更新Netty系列一共九篇 当前：Netty 源码解析（一）开始 Netty 源码解析（二）: Netty 的 Channel Netty 源码解析（三）: Netty 的 Future 和 Promise Netty 源码解析（四）: Netty 的 ChannelPipeline Netty 源码解析（五）: Netty 的线程...
netty4源码分析-bind
海浪儿
08-13 195
本文为原创，转载请注明出处 netty4源码分析-bind  在前一篇文章中分析了监听套接字ServerSocketChannel的创建过程，本文接着分析绑定IP和端口的过程。  回到之前未分析完的doBind逻辑，前一篇文章已分析到dobind方法中initAndRegister方法，该方法最终触发了对regPromise 的listener的回调，Listener将bind任务加到b...
netty4源码分析-socket
海浪儿
08-12 113
本文为原创，转载请注明出处 netty4源码分析-socket        服务端启动的第一步必须先创建一个监听套接字ServerSocketChannel，该过程是由ChannelFuture f = b.bind(port)中的bind触发。下面详细分析其过程：        Bind源码如下，代码位于ServerBootstrap的父类AbstractBootstrap //A...
NioEventLoop加载流程分析
lipengyao2010的专栏
09-26 230
一、我们首先看NioEventLoopGroup创建和初始化过程。 EventLoopGroup workEventLoopGroup = new NioEventLoopGroup(new NamedThreadFactory("clientThread", false)); 1.看下类继承图 2.MultithreadEventLoopGroup父类实现了channel的接口注册，next取下一个可用的NioEventLoop @Override public Event.
（三）Netty服务启动过程源码分析 — Selector的构建和优化
OrPis的专栏
11-17 576
前言 继上一篇讲完了Channel的注册和初始化后，我们看看Netty的Selector是如何创建的，以及Netty是如何对他进行优化的 正文 io.netty.channel.nio.NioEventLoop // 在NioEventLoop初始化的时候，在构造方法里会调用openSelector()方法 private SelectorTuple openSelector() { final Selector unwrappedSelector;
Netty源码解析：客户端接入与NioEventLoop详解
在整个系列文章中，作者李林峰详细解析了Netty从入门到进阶的内容，包括传统BIO编程的对比、服务器端和客户端的创建、消息的发送与接收、线程模型的构建、框架的架构剖析，以及实战案例分析。这些深入浅出的讲解，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值