NioEventLoop之ioRatio

代码参考netty4

源码入口在这，先大概看下，大概：

protected void run() {
        int selectCnt = 0;
        for (;;) {
            try {
                int strategy;
                try {
                    strategy = selectStrategy.calculateStrategy(selectNowSupplier, hasTasks());
                    switch (strategy) {
                    case SelectStrategy.CONTINUE:
                        continue;

                    case SelectStrategy.BUSY_WAIT:
                        // fall-through to SELECT since the busy-wait is not supported with NIO

                    case SelectStrategy.SELECT:
                        long curDeadlineNanos = nextScheduledTaskDeadlineNanos();
                        if (curDeadlineNanos == -1L) {
                            curDeadlineNanos = NONE; // nothing on the calendar
                        }
                        nextWakeupNanos.set(curDeadlineNanos);
                        try {
                            if (!hasTasks()) {
                                strategy = select(curDeadlineNanos);
                            }
                        } finally {
                            // This update is just to help block unnecessary selector wakeups
                            // so use of lazySet is ok (no race condition)
                            nextWakeupNanos.lazySet(AWAKE);
                        }
                        // fall through
                    default:
                    }
                } catch (IOException e) {
                    // If we receive an IOException here its because the Selector is messed up. Let's rebuild
                    // the selector and retry. https://github.com/netty/netty/issues/8566
                    rebuildSelector0();
                    selectCnt = 0;
                    handleLoopException(e);
                    continue;
                }

                selectCnt++;
                cancelledKeys = 0;
                needsToSelectAgain = false;
                final int ioRatio = this.ioRatio;//这里开始
                boolean ranTasks;
                if (ioRatio == 100) {
                    try {
                        if (strategy > 0) {
                            processSelectedKeys();
                        }
                    } finally {
                        // Ensure we always run tasks.
                        ranTasks = runAllTasks();
                    }
                } else if (strategy > 0) {
                    final long ioStartTime = System.nanoTime();
                    try {
                        processSelectedKeys();
                    } finally {
                        // Ensure we always run tasks.
                        final long ioTime = System.nanoTime() - ioStartTime;
                        ranTasks = runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
                    }
                } else {
                    ranTasks = runAllTasks(0); // This will run the minimum number of tasks
                }

                if (ranTasks || strategy > 0) {
                    if (selectCnt > MIN_PREMATURE_SELECTOR_RETURNS && logger.isDebugEnabled()) {
                        logger.debug("Selector.select() returned prematurely {} times in a row for Selector {}.",
                                selectCnt - 1, selector);
                    }
                    selectCnt = 0;
                } else if (unexpectedSelectorWakeup(selectCnt)) { // Unexpected wakeup (unusual case)
                    selectCnt = 0;
                }
            } catch (CancelledKeyException e) {
                // Harmless exception - log anyway
                if (logger.isDebugEnabled()) {
                    logger.debug(CancelledKeyException.class.getSimpleName() + " raised by a Selector {} - JDK bug?",
                            selector, e);
                }
            } catch (Throwable t) {
                handleLoopException(t);
            }
            // Always handle shutdown even if the loop processing threw an exception.
            try {
                if (isShuttingDown()) {
                    closeAll();
                    if (confirmShutdown()) {
                        return;
                    }
                }
            } catch (Throwable t) {
                handleLoopException(t);
            }
        }
    }

1，介绍
ioRadio：表示NioEventLoop线程每次循环处理IO事件之后，还需要处理异步任务(即非IO事件），单次处理IO和异步任务的事件占比，总数是100
如果ioRatio=50，即表示处理io和异步任务的时间各占一半
如果ioRatio=30，即io处理时间/异步任务执行时间为3:7

2，看逻辑代码

if (ioRatio == 100) {
// 1，如果ioRatio为100，即直接处理selector io事件，但确保在finally中还会执行异步任务
   try {
       if (strategy > 0) {
       // 1.1 如果io事件个数大于0，即处理io事件
           processSelectedKeys();
       }
   } finally {
       // Ensure we always run tasks.
       // 1.2 确保会一直执行异步任务
       ranTasks = runAllTasks();
   }
} else if (strategy > 0) {
	// 2.1 如果ioRatio !=100，但是又有io事件发生，那么先处理io事件
   final long ioStartTime = System.nanoTime();
   try {
       processSelectedKeys();
   } finally {
       // Ensure we always run tasks.
       // 2，执行完io事件后，计算剩余的可执行异步任务的时间，
       // 如果ioRatio为30，已经执行的io时间耗时为100ms，
       //那么剩余可供执行异步任务的时间为(100*(100-30)/30)=233ms
       final long ioTime = System.nanoTime() - ioStartTime;
       ranTasks = runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
   }
} else {
    // 3，如果ioRatio!=100，并且又没有io时间，那么执行执行异步任务
   ranTasks = runAllTasks(0); // This will run the minimum number of tasks
}

3，这个参数也是可配的，参考

/**
     * Sets the percentage of the desired amount of time spent for I/O in the event loop. Value range from 1-100.
     * The default value is {@code 50}, which means the event loop will try to spend the same amount of time for I/O
     * as for non-I/O tasks. The lower the number the more time can be spent on non-I/O tasks. If value set to
     * {@code 100}, this feature will be disabled and event loop will not attempt to balance I/O and non-I/O tasks.
     */
    public void setIoRatio(int ioRatio) {
        if (ioRatio <= 0 || ioRatio > 100) {
            throw new IllegalArgumentException("ioRatio: " + ioRatio + " (expected: 0 < ioRatio <= 100)");
        }
        this.ioRatio = ioRatio;
    }

意思就是，使用这个参数来平衡io事件和非io任务的时间使用占比