netty的EventLoop选择策略

发表于 分类于 Waline： 阅读次数：

netty 中的 channel 在完成创建和初始化之后，需要注册到 EventLoopGroup 上，这本质上是交给 EventLoop 管理 channel 的各种事件。一个 EventLoopGroup 管理了多个 EventLoop，那么在注册 channel 时，EventLoopGroup 就需要选择一个 EventLoop，然后将其和 channel 关联起来。选择 EventLoop 是一个很高频的操作，该操作是否高效会直接影响 netty 的性能，本文就来聊下 EventLoop 的选择策略。

image-20210102175908637

netty 使用 EventExecutorChooserFactory.EventExecutorChooser 选择要使用的 EventLoop

1
2
3
4
5
6
7
8
9
10
11
12
13
private final EventExecutorChooserFactory.EventExecutorChooser chooser;

// MultithreadEventExecutorGroup
protected MultithreadEventExecutorGroup(int nThreads, Executor executor,
                                        EventExecutorChooserFactory chooserFactory, Object... args) {
    // 省略其他代码...
    children = new EventExecutor[nThreads];
    chooser = chooserFactory.newChooser(children);
}

public EventExecutor next() {
    return chooser.next();
}

EventExecutorChooser 是一个接口，它只有一个 next() 方法，用于获取一个 EventExecutor（对于 EventLoopGroup 来说，就是获取一个 EventLoop）

1
2
3
4
5
6
interface EventExecutorChooser {
    /**
     * Returns the new {@link EventExecutor} to use.
     */
    EventExecutor next();
}

EventExecutorChooser 共有两种实现，分别是 GenericEventExecutorChooser 和 PowerOfTwoEventExecutorChooser，本质上这两种策略都是最简单的轮询策略，他们的区别在于具体的实现。

GenericEventExecutorChooser

GenericEventExecutorChooser 是一个通用的选择器，它的代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private static final class GenericEventExecutorChooser implements EventExecutorChooser {
    // Use a 'long' counter to avoid non-round-robin behaviour at the 32-bit overflow boundary.
    // The 64-bit long solves this by placing the overflow so far into the future, that no system
    // will encounter this in practice.
    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)];
    }
}

它内部使用一个数组保存了所有可用的 executor，使用一个 AtomicLong 类型的元素作为 counter 计数器。每次取元素时根据 counter 和数组长度取余计算数组下标，取完数据后 counter 加一。其中 getAndIncrement 保证了操作的原子性，避免了并发问题。

1
2
3
index = id % length       # 计算下标
id = id + 1               # 下标加一
return executors[index]   # 返回数组元素

PowerOfTwoEventExecutorChooser

PowerOfTwoEventExecutorChooser 是另外一种选择器，它也是采用的轮询的策略。对于轮询策略来说，当数组长度是 2 的幂次方时，我们可以通过位运算计算数组下标。

1
index = id & (length - 1)

和取余操作相比，位运算是一种更高效的计算方式，这对于性能的提升有一定的效果。

1
2
3
4
5
6
7
8
9
10
11
12
13
private static final class PowerOfTwoEventExecutorChooser implements EventExecutorChooser {
    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 的缺点是对数组的长度有要求，这样对于不符合要求的情况就只能使用 GenericEventExecutorChooser ，这也是 EventExecutorChooserFactory 要做的工作

EventExecutorChooserFactory

1
2
3
4
5
6
7
public interface EventExecutorChooserFactory {

    /**
     * Returns a new {@link EventExecutorChooser}.
     */
    EventExecutorChooser newChooser(EventExecutor[] executors);
}

EventExecutorChooserFactory 用于生成 EventExecutorChooser ，它考虑的因素是 executors 数组的长度，当长度是 2 的幂次方时使用 PowerOfTwoEventExecutorChooser ，否则使用 GenericEventExecutorChooser

1
2
3
4
5
6
7
8
9
10
11
12
// DefaultEventExecutorChooserFactory.newChooser
public EventExecutorChooser newChooser(EventExecutor[] executors) {
    if (isPowerOfTwo(executors.length)) {
        return new PowerOfTwoEventExecutorChooser(executors);
    } else {
        return new GenericEventExecutorChooser(executors);
    }
}

private static boolean isPowerOfTwo(int val) {
    return (val & -val) == val;
}

判断是否为2的幂次方

2 的幂次方一定大于 0，当确认数字大于 0 时，可以用以下方法判断

方法一

1
return (val & -val) == val;

示例

1
2
3
16       = 00000000000000000000000000010000
-16      = 11111111111111111111111111110000
16 & -16 = 00000000000000000000000000010000

方法二

1
return (val & val - 1 == 0)

示例

1
2
3
16       = 00000000000000000000000000010000
15       = 00000000000000000000000000001111
16 & 15  = 00000000000000000000000000000000
相关文章