Netty ---源码剖析

EventLoopGroup bossGroup =new NioEventLoopGroup();
EventLoopGroup workGroup =new NioEventLoopGroup();

            /**
            
 * {
            @link
             MultithreadEventLoopGroup} implementations which is used for NIO {
            @link
             Selector} based {
            @link
             Channel}s.
 
            */
            public
            class NioEventLoopGroup extends MultithreadEventLoopGroup {

  */
    public NioEventLoopGroup() {
        this(0);
    }

    /**
     * Create a new instance using the specified number of threads, {@link ThreadFactory} and the
     * {@link SelectorProvider} which is returned by {@link SelectorProvider#provider()}.
     */public NioEventLoopGroup(int nThreads) {
        this(nThreads, (Executor) null);
    }

            /**
            
　　* Create a new instance using the specified number of threads, the given {
            @link
             ThreadFactory} and the
　　* {
            @link
             SelectorProvider} which is returned by {
            @link
             SelectorProvider#provider()}.
　　
            */
            public NioEventLoopGroup(int nThreads, Executor executor) {
this(nThreads, executor, SelectorProvider.provider());
}

            public
             NioEventLoopGroup(

            int nThreads, Executor executor, final SelectorProvider selectorProvider) {
this(nThreads, executor, selectorProvider, DefaultSelectStrategyFactory.INSTANCE);
}

//在这个构造方法里用添加了一个参数  DefaultSelectStrategyFactory.INSTANCE ，提供一个默认选择策略，工厂模式
/**
* Factory which uses the default select strategy.
*/publicfinalclass DefaultSelectStrategyFactory implements SelectStrategyFactory {
publicstaticfinal SelectStrategyFactory INSTANCE = new DefaultSelectStrategyFactory();

private DefaultSelectStrategyFactory() { }

@Override
public SelectStrategy newSelectStrategy() {
return DefaultSelectStrategy.INSTANCE;
}
}

            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) { 
super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args); }

//分析线程数量
//线程数量判断，如果是0的话，就是 DEFAULT_EVENT_LOOP_THREADS  ，是多少呢？我们点进去看一看，我们会看到一个静态代码块static {
DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
"io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2));

if (logger.isDebugEnabled()) {
logger.debug("-Dio.netty.eventLoopThreads: {}", DEFAULT_EVENT_LOOP_THREADS);
}
}


//调用Runtime.availableProcessors将会获取 可用的处理器
@SuppressForbidden(reason = "to obtain default number of available processors")
synchronizedint availableProcessors() {
if (this.availableProcessors == 0) {
finalint availableProcessors =
SystemPropertyUtil.getInt(
"io.netty.availableProcessors",
Runtime.getRuntime().availableProcessors());
setAvailableProcessors(availableProcessors);
}
returnthis.availableProcessors;
}



由此可以看到 默认创建的线程数不是0 而是根据不同电脑的处理器个数*2

            protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}

protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
EventExecutorChooserFactory chooserFactory, Object... args) {
if (nThreads <= 0) {
thrownew IllegalArgumentException(String.format("nThreads: %d (expected: > 0)", nThreads));
}

//**********源码解释***********//
//我们看红色部分，就是对 executor 进行初始化操作，这里我们需要了解的是Excutor 接口 以及ThreadFactory 接口的作用
//在netty 里实现了ThreadFactory关于自己的DefaultThreadFactory

            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 typethrownew 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
publicvoid 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);
}