netty教程(三)——NioEventLoopGroup创建

最新推荐文章于 2024-08-25 18:26:06 发布

yygr

最新推荐文章于 2024-08-25 18:26:06 发布

阅读量362

点赞数

分类专栏： # io 文章标签： io

原文链接：https://juejin.cn/post/6887756255868387336

版权

io 专栏收录该内容

48 篇文章 8 订阅

订阅专栏

https://juejin.cn/user/1451011081254792/posts

以netty的一个小demo为例（使用的源码版本为4.1.50.Final）

demo里使用到了NioEventLoopGroup ,一路跟进会调用到这个类一个比较复杂的构函数

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

这里调用到了父类的一个构造函数

protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) {
    //DEFAULT_EVENT_LOOP_THREADS为两倍cpu核数
    super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args);
}

最终会调用到的MultithreadEventExecutorGroup的一个构造函数

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                            EventExecutorChooserFactory chooserFactory, Object... args) {
    if (nThreads <= 0) {
        //省略
    }

    //executor是线程执行器
    if (executor == null) {
        executor = new ThreadPerTaskExecutor(newDefaultThreadFactory());
    }

    //nThreads等于2倍cpu核数
    children = new EventExecutor[nThreads];

    for (int i = 0; i < nThreads; i ++) {
        boolean success = false;
        try {
            //创建NioEventLoop
            children[i] = newChild(executor, args);
            success = true;
        } catch (Exception e) {
            //省略
        } finally {
            if (!success) {
                //省略
            }
        }
    }
    //创建线程选择器
    chooser = chooserFactory.newChooser(children);

    //线程终止监听等其他代码，省略
}

可以看到，主要做了三件事

创建线程执行器ThreadPerTaskExecutor
创建2倍cpu核数的NioEventLoop
创建线程选择器

创建ThreadPerTaskExecutor

这个类很简单

public final class ThreadPerTaskExecutor implements Executor {
    private final ThreadFactory threadFactory;

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

    @Override
    public void execute(Runnable command) {
        threadFactory.newThread(command).start();
    }
}

可以看到，这个类就是通过传入的threadFactory，每次执行任务时调用threadFactory创建线程执行

而这个threadFactory是通过newDefaultThreadFactory这个方法创建的

protected ThreadFactory newDefaultThreadFactory() {
    return new DefaultThreadFactory(getClass());
}

这里会创建一个DefaultThreadFactory类，最终调用到这个类的一个构造函数

public DefaultThreadFactory(String poolName, boolean daemon, int priority, ThreadGroup threadGroup) {
    ObjectUtil.checkNotNull(poolName, "poolName");

    if (priority < Thread.MIN_PRIORITY || priority > Thread.MAX_PRIORITY) {
        //省略
    }

    //poolName的值为nioEventLoop
    prefix = poolName + '-' + poolId.incrementAndGet() + '-';
    //daemon为false
    this.daemon = daemon;
    //priority的值为Thread.NORM_PRIORITY
    this.priority = priority;
    this.threadGroup = threadGroup;
}

而DefaultThreadFactory#newThread方法如下

public Thread newThread(Runnable r) {
    Thread t = newThread(FastThreadLocalRunnable.wrap(r), prefix + nextId.incrementAndGet());
    try {
        if (t.isDaemon() != daemon) {
            t.setDaemon(daemon);
        }

        if (t.getPriority() != priority) {
            t.setPriority(priority);
        }
    } catch (Exception ignored) {
        // Doesn't matter even if failed to set.
    }
    return t;
}

所以，NioEventLoop创建的线程的命名规则为nioEventLoop-1-xx形式

并且使用的Thread也不是原生的Thread二是FastThreadLocalThread（主要是对ThreadLocal做了优化）

创建NioEventLoop

上面newChild方法最终会调用NioEventLoop的一个构造函数

NioEventLoop(NioEventLoopGroup parent, 
             Executor executor, 
             SelectorProvider selectorProvider,
             SelectStrategy strategy, 
             RejectedExecutionHandler rejectedExecutionHandler,
             EventLoopTaskQueueFactory queueFactory) {
    //调用父类构造函数设置一些成员变量
    super(parent, executor, false, newTaskQueue(queueFactory), newTaskQueue(queueFactory),
          rejectedExecutionHandler);
    this.provider = ObjectUtil.checkNotNull(selectorProvider, "selectorProvider");
    this.selectStrategy = ObjectUtil.checkNotNull(strategy, "selectStrategy");
    //openSelector就是调用了provider.openSelector()方法
    final SelectorTuple selectorTuple = openSelector();
    this.selector = selectorTuple.selector;
    this.unwrappedSelector = selectorTuple.unwrappedSelector;
}

注意到，这里