2022-03-30_netty事件循环NioEventLoopGroup多线程源码学习笔记.md

20220330_netty事件循环NioEventLoopGroup多线程源码学习笔记.md

1概述

本文基于netty版本,V4.1.68.Final-SNAPSHOT。

事件循环EventLoop完全是一个Thread,本质是一个线程,继承了事件循环组接口EventLoopGroup和事件执行器接口OrderEventExecutor,但没有实现。

nioEventLoopGroup线程池创建的最大区别就是,netty自定义了ThreadPerTaskExecutor执行器进行线程的创建。而没有使用Jdk中的Executor(ThreadPoolExecutor),至于任务调度方式是一样的。

为了合理利用资源,根据配置和可用的内核，netty可用使用多个EventLoop即多个线程。

1.1相关类图

1.1.1EventLoop接口关系图

public interface EventLoop extends OrderedEventExecutor, EventLoopGroup {

[图片上传失败...(image-ea9bf3-1653897509473)]

1.1.2SingleThreadEventLoop抽象类关系图

[图片上传失败...(image-afee6f-1653897509474)]

1.1.2.1DefaultEventLoop类关系图

    public DefaultEventLoop(EventLoopGroup parent, ThreadFactory threadFactory) {
        
        // addTaskWakesUp:true,由JDK队列进行阻塞唤醒
        super(parent, threadFactory, true);
    }

[图片上传失败...(image-8f488-1653897509474)]

1.1.2.2NioEventLoop类(单线程)

NioEventLoop(NioEventLoopGroup parent, Executor executor, SelectorProvider selectorProvider,
                 SelectStrategy strategy, RejectedExecutionHandler rejectedExecutionHandler,
                 EventLoopTaskQueueFactory taskQueueFactory, EventLoopTaskQueueFactory tailTaskQueueFactory) {
        // addTaskWakesUp:false,需要人为增加一个NOP队列任务唤醒IO任务
        super(parent, executor, false, newTaskQueue(taskQueueFactory), newTaskQueue(tailTaskQueueFactory),
                rejectedExecutionHandler);
    

[图片上传失败...(image-fec97e-1653897509474)]

1. SingleThreadEventExecutor抽象类:延时任务,获取待执行和过期任务,并执行,内置Queue taskQueue。

2. SingleThreadEventLoop抽象类:实现EventLoopGroup接口中的next,注册等方法,内置额外的时间循环任务队列,tailTasks queue,作为参数给SingleThreadEventExecutor.runAllTasksFrom调用,问题来了,taskQueue不够吗?

   protected final boolean runAllTasksFrom(Queue taskQueue) {。
   

3. DefaultEventLoop:无限循环,实现从队列中取任务,执行任务等一些列的。

// E:\workdirectory\Dev\study\netty-4.1\transport\src\main\java\io\netty\channel\DefaultEventLoop.java

// 实现了SingleThreadEventExecutor抽象类的run方法。
@Override
    protected void run() {
        for (;;) {
            // 1.调用SingleThreadEventExecutor.takeTask获取任务。
            Runnable task = takeTask();
            if (task != null) {
                task.run();
                // 3.调用SingleThreadEventExecutor.updateLastExecutionTime
                updateLastExecutionTime();
            }

            // 3.调用SingleThreadEventExecutor.confirmShutdown
            if (confirmShutdown()) {
                break;
            }
        }
    }

1.1.3MultithreadEventLoopGroup抽象类

public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {

[图片上传失败...(image-96b39c-1653897509474)]

1.1.3.1NioEventLoopGroup类(多线程)

public class NioEventLoopGroup extends MultithreadEventLoopGroup {

[图片上传失败...(image-581924-1653897509474)]

1.2多线程启动源码分析

1.2.1构建NioEventLoopGroup

// E:\workdirectory\Dev\study\netty-4.1\transport\src\main\java\io\netty\channel\nio\NioEventLoopGroup.java
public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                             final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
    }
// E:\workdirectory\Dev\study\netty-4.1\transport\src\main\java\io\netty\channel\MultithreadEventLoopGroup.java
protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
        super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
    }

// E:\workdirectory\Dev\study\netty-4.1\common\src\main\java\io\netty\util\concurrent\MultithreadEventExecutorGroup.java
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
        this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
    }

1.2.2线程池的创建(非JDK方式)

[图片上传失败...(image-ce8b20-1653897509474)]

public abstract class MultithreadEventExecutorGroup extends AbstractEventExecutorGroup {
    // 本质:NioEventLoop
    private final EventExecutor[] children;

/**
     * Create a new instance.
     *
     * @param nThreads          the number of threads that will be used by this instance.
     * @param executor          the Executor to use, or {@code null} if the default should be used.
     * @param chooserFactory    the {@link EventExecutorChooserFactory} to use.
     * @param args              arguments which will passed to each {@link #newChild(Executor, Object...)} call
     */
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
        checkPositive(nThreads, "nThreads");

        // 1.构建 executor,ThreadPerTaskExecutor等同于 JDK ThreadPoolExecutor
        if (executor == null) {
            executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
        }
        // 2.创建指定线程数量的NioEventLoop
        children = new EventExecutor[nThreads];

        for (int i = 0; i < nThreads; i ++) {
            boolean success = false;
            try {
                // 2.1.创建NioEventLoop,默执行器:ThreadPerTaskExecutor
                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