Netty 용어사전

public class NioEventLoopGroup extends MultithreadEventLoopGroup {

public class NioEventLoopGroup extends MultithreadEventLoopGroup {
    public NioEventLoopGroup() {
        this(0);
    }
    // ...
    public NioEventLoopGroup(int nThreads, Executor executor, final SelectorProvider selectorProvider,
                             final SelectStrategyFactory selectStrategyFactory) {
        super(nThreads, executor, selectorProvider, selectStrategyFactory, RejectedExecutionHandlers.reject());
    }
}

public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {
    private static final int DEFAULT_EVENT_LOOP_THREADS;

    static {
        DEFAULT_EVENT_LOOP_THREADS = Math.max(1, SystemPropertyUtil.getInt(
            "io.netty.eventLoopThreads", NettyRuntime.availableProcessors() * 2)); // <-- CPU 코어 갯수에 2를 곱하고  있다.
    }

    protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) { 
        super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args); // <-- 기본 생성자는 nThreads가 0이다.
    }
}

public final class NettyRuntime {
    public static int availableProcessors() {
        return holder.availableProcessors();
    }

    private static final AvailableProcessorsHolder holder = new AvailableProcessorsHolder();
    static class AvailableProcessorsHolder {
        private int availableProcessors;
        synchronized int availableProcessors() { 
            if (this.availableProcessors == 0) { 
                final int availableProcessors = 
                        SystemPropertyUtil.getInt(
                            "io.netty.availableProcessors", 
                            Runtime.getRuntime().availableProcessors() // <-- 여기에서 CPU 코어 갯수를 반환함.
                        );
                setAvailableProcessors(availableProcessors); 
            }
            return this.availableProcessors; 
        }

        synchronized void setAvailableProcessors(final int availableProcessors) { 
            ObjectUtil.checkPositive(availableProcessors, "availableProcessors");
            if (this.availableProcessors != 0) { 
                final String message = String.format(
                    Locale.ROOT, 
                    "availableProcessors is already set to [%d], rejecting [%d]", 
                    this.availableProcessors, 
                    availableProcessors
                );
                throw new IllegalStateException(message); 
            }
            this.availableProcessors = availableProcessors; 
        }
    }
}

public abstract class MultithreadEventLoopGroup extends MultithreadEventExecutorGroup implements EventLoopGroup {
    protected MultithreadEventLoopGroup(int nThreads, Executor executor, Object... args) { 
        super(nThreads == 0 ? DEFAULT_EVENT_LOOP_THREADS : nThreads, executor, args); // <-- 기본 생성자는 nThreads가 0이다.
    }
    
    protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
        this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args); 
    }

    private final EventExecutor[] children;

    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]; // 코어 갯수 * 2개의 배열 생성

        for (int i = 0; i < nThreads; i ++) { // 코어 갯수 * 2개만큼 반복
            boolean success = false;
            try { 
                children[i] = newChild(executor, args);
                // ...
            }
        }
    }
}

public class NioEventLoopGroup extends MultithreadEventLoopGroup {
    @Override
    protected EventLoop newChild(Executor executor, Object... args) throws Exception {
        EventLoopTaskQueueFactory queueFactory = args.length == 4 ? (EventLoopTaskQueueFactory) args[3] : null;
        return new NioEventLoop(this, executor, (SelectorProvider) args[0], 
                ((SelectStrategyFactory) args[1]).newSelectStrategy(), (RejectedExecutionHandler) args[2], queueFactory); 
    }
}

public final class NioEventLoop extends SingleThreadEventLoop {
    @Override
    protected void run() {
        int selectCnt = 0;
        for (; ; ) { // 무한 반복
            // ...
        }
    }
}

public final class NioEventLoop extends SingleThreadEventLoop {
    private final SelectorProvider provider;
  
    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");
        final SelectorTuple selectorTuple = openSelector();
        this.selector = selectorTuple.selector;
        this.unwrappedSelector = selectorTuple.unwrappedSelector; 
    }
    
    private final IntSupplier selectNowSupplier = new IntSupplier() {
        @Override 
        public int get() throws Exception { 
            return selectNow(); 
        }
    };
    
    int selectNow() throws IOException { 
        return selector.selectNow(); 
    }
}

final class SelectedSelectionKeySetSelector extends Selector {
    private final SelectedSelectionKeySet selectionKeys;
    private final Selector delegate;

    @Override
    public int selectNow() throws IOException {
        selectionKeys.reset();
        return delegate.selectNow();
    }
}

public abstract class SelectorImpl
        extends AbstractSelector
{
  public int selectNow() throws IOException {
    return lockAndDoSelect(0);
  }
  
  private int lockAndDoSelect(long timeout) throws IOException {
    synchronized (this) {
      if (!isOpen())
        throw new ClosedSelectorException();
      synchronized (publicKeys) {
        synchronized (publicSelectedKeys) {
          return doSelect(timeout);
        }
      }
    }
  }
}

class KQueueSelectorImpl extends SelectorImpl {
    protected int doSelect(long var1) throws IOException { 
        boolean var3 = false;
        if (this.closed) { 
            throw new ClosedSelectorException(); 
        } else { 
            this.processDeregisterQueue();
            
            int var7;
            try { 
                this.begin();
                var7 = this.kqueueWrapper.poll(var1); 
            } finally { 
                this.end(); 
            }
            
            this.processDeregisterQueue();
            return this.updateSelectedKeys(var7); 
        } 
    }
}

class KQueueArrayWrapper { 
    int poll(long var1) { 
        this.updateRegistrations();
        // var1은 timeout에서 넘어온 0이므로 블락시키지 않고 바로 다음 구문으로 간다.
        int var3 = this.kevent0(this.kq, this.keventArrayAddress, 128, var1);
        return var3; 
    }
    
    private native int kevent0(int var1, long var2, int var4, long var5);
}