聊一聊Netty中的执行器选择策略
前言
在前面的一篇博文中有写到：当执行器组EventLoopGroup在执行register(Channel channel)方法注册通道时，首先后会使用next()方法从执行器组中选择一个执行器来执行。至于next()方法如何去选择一个执行器，就是本文要聊的东东。
Netty的执行器选择器工厂与选择器
在NioEventLoopGroup实例化过程中，会调用其父类的MultithreadEventExecutorGroup构造方法，如果没有传入选择器工厂，则使用默认的DefaultEventExecutorChooserFactory。
MultithreadEventExecutorGroup中的构造方法：
protected MultithreadEventExecutorGroup(int nThreads, Executor executor, Object... args) {
//使用DefaultEventExecutorChooserFactory对象作为选择器工厂
//继续调用其他构造方法
this(nThreads, executor, DefaultEventExecutorChooserFactory.INSTANCE, args);
}
其中DefaultEventExecutorChooserFactory.INSTANCE返回的是一个单例模式下的DefaultEventExecutorChooserFactory对象。
public final class DefaultEventExecutorChooserFactory implements EventExecutorChooserFactory {
//默认的执行器选择器工厂
public static final DefaultEventExecutorChooserFactory INSTANCE = new DefaultEventExecutorChooserFactory();
/*
* 省略其他代码
*/
}
跟进MultithreadEventExecutorGroup的另一个构造方法中：
（省略了大量与本文内容无关的代码）
//这里传入的chooserFactory就是上面的构造方法中说的DefaultEventExecutorChooserFactory对象
protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
EventExecutorChooserFactory chooserFactory, Object... args) {
checkPositive(nThreads, "nThreads");
//创建执行器数组，存储执行器
children = new EventExecutor[nThreads];
/*省略与本文内容无关的代码*/
//创建一个执行器选择器
chooser = chooserFactory.newChooser(children);
/*省略与本文内容无关的代码*/
}
在这个构造方法中，首先会根据线程数量来创建一个执行器数组，然后使用选择器工厂chooserFactory的newChooser方法来创建选择器。
然后，继续跟入DefaultEventExecutorChooserFactory的newChooser方法：
public EventExecutorChooser newChooser(EventExecutor[] executors) {
//如果执行器的数量是2的倍数
if (isPowerOfTwo(executors.length)) {
return new PowerOfTwoEventExecutorChooser(executors);
} else {
//普通选择器
return new GenericEventExecutorChooser(executors);
}
}
这里，首先调用isPowerOfTwo判断执行器数量是不是2的幂，
//判断是否是2的次幂
private static boolean isPowerOfTwo(int val) {
return (val & -val) == val;
}
(val & -val) == val是一种快速判断val是不是2的幂的方法， -val 表示n的二进制补码的相反数。(val & -val)的结果是n的二进制表示中最右边的 1所对应的位。这意味着只有当val是2的幂时，(val & -val)的结果才等于val。
如果执行器的数量是2的幂，则使用PowerOfTwoEventExecutorChooser作为选择器，
//如果执行器的数量是2的倍数
private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
//从0开始的计数器
private final AtomicInteger idx = new AtomicInteger();
//执行器数组
private final EventExecutor[] executors;
//构造方法
PowerOfTwoEventExecutorChooser(EventExecutor[] executors) {
this.executors = executors;
}
//选择其中一个执行器
@Override
public EventExecutor next() {
return executors[idx.getAndIncrement() & executors.length - 1];
}
}
在PowerOfTwoEventExecutorChooser中，会定义一个从0开始的计数器，每次执行next()选择执行器以后，会将计数器的值增加1，根据计数器的值idx使用“ idx & executors.length - 1”方法来快速取模。
在Java语言中，算术运算符的优先级比位运算符高，因此“idx & executors.length - 1”等同于
“idx & (executors.length - 1)”。
当idx 为2的幂时，“idx & (executors.length - 1)”结果等于“idx % (executors.length - 1)”。
这种快速取模法和HashMap源码中的计算节点在哈希表位置时使用的快速取模法一模一样，只不过HashMap用的是哈希值和数组长度减去1后进行位运算。
我觉得，HashMap中哈希表的扩容之所以要以2倍来扩容，有一部分原因就是为了保证哈希表的长度始终是2的幂，这样就节点插入时就能使用这种快速取模法。
如果执行器的数量不是2的幂，则会使用GenericEventExecutorChooser作为选择器。
private static final class GenericEventExecutorChooser implements EventExecutorChooser {
//创建一个从0 开始的计数器
private final AtomicLong idx = new AtomicLong();
//执行器数组
private final EventExecutor[] executors;
GenericEventExecutorChooser(EventExecutor[] executors) {
this.executors = executors;
}
@Override
public EventExecutor next() {
return executors[(int) Math.abs(idx.getAndIncrement() % executors.length)];
}
}
逻辑和上面的基本一样，只不过取模方式是用“%”算术运算符来进行取模。
总结与思考
Netty中的执行器选择策略很简单，使用一个每次递增的计数器，然后每次执行next()选取执行器时，将计数器的值和执行器的数量进行取模。根据执行器的数量是不是2的幂，决定使用快速取模法和普通取模法。
不过笔者对这个DefaultEventExecutorChooserFactory代码有点疑问，在PowerOfTwoEventExecutorChooser 选择器中，其计数器使用的是AtomicInteger类型；在GenericEventExecutorChooser选择器中，其计数器使用的是AtomicLong型。为什么要不一样呢？