Netty使用案例 -优雅退出原理和源码分析
文章目录
- 优雅退出原理和源码分析
- NioEventLoopGroup
- NioEventLoop
- 调试总结
优雅退出原理和源码分析
Netty优雅退出涉及线程组，NIO线程，Channel和定时任务等，底层实现细节比较复杂。看看源码是怎么实现的。
NioEventLoopGroup
NioEventLoopGroup实际上是NioEventLoop线程组，它的优雅退出比较简单，可直接遍历EventLoop数组，循环调用它们的shutdownGracefully方法，源码
public abstract class MultithreadEventExecutorGroup extends AbstractEventExecutorGroup {
private final EventExecutor[] children;
...
@Override
public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) {
//这里循环优雅关闭
for (EventExecutor l: children) {
l.shutdownGracefully(quietPeriod, timeout, unit);
}
return terminationFuture();
}
}
对于线程组内每个NioEventLoop执行的关闭。
NioEventLoop
NioEventLoop运行执行选择器，在执行时候会判断是否在关闭状态或者已经关闭。
public final class NioEventLoop extends SingleThreadEventLoop {
@Override
protected void run() {
for (;;) {
try {
switch (selectStrategy.calculateStrategy(selectNowSupplier, hasTasks())) {
//选择是否执行准备好
case SelectStrategy.CONTINUE:
continue;
case SelectStrategy.SELECT:
select(wakenUp.getAndSet(false));
// 'wakenUp' 太早设置为true:
// 1) 选择器在wakenUp.set(false)唤醒代价比较大 // 'selector.select(...)'. (BAD)
// 2) 先判断是否需要唤醒减少立即唤醒的损失 // 'if (wakenUp.get()) { ... }'. (OK)
if (wakenUp.get()) {
selector.wakeup();
}
// fall through
default:
}
cancelledKeys = 0;
needsToSelectAgain = false;
final int ioRatio = this.ioRatio;
if (ioRatio == 100) {
try {
processSelectedKeys();
} finally {
// Ensure we always run tasks.
runAllTasks();
}
} else {
final long ioStartTime = System.nanoTime();
try {
processSelectedKeys();
} finally {
// Ensure we always run tasks.
final long ioTime = System.nanoTime() - ioStartTime;
runAllTasks(ioTime * (100 - ioRatio) / ioRatio);
}
}
} catch (Throwable t) {
handleLoopException(t);
}
// Always handle shutdown even if the loop processing threw an exception.
try {
//判断是否已经关闭，看后边对shutdownGracefully的分析
if (isShuttingDown()) {
//关闭注册到selector上的所有的Channel，查看下边对closeAll分析
closeAll();
if (confirmShutdown()) {
return;
}
}
} catch (Throwable t) {
handleLoopException(t);
}
}
}
调用NioEventLoop的shutdownGracefully方法，首先要修改线程状态为正在关闭状态，它的实现在父类SingleTreadEventExecutor中，
ublic abstract class SingleThreadEventExecutor extends AbstractScheduledEventExecutor implements OrderedEventExecutor {
private static final InternalLogger logger =
InternalLoggerFactory.getInstance(SingleThreadEventExecutor.class);
private static final int ST_NOT_STARTED = 1;
private static final int ST_STARTED = 2;
//设置正在关闭状态
private static final int ST_SHUTTING_DOWN = 3;
private static final int ST_SHUTDOWN = 4;
private static final int ST_TERMINATED = 5;
/**
* Add a {@link Runnable} which will be executed on shutdown of this instance
*/
public void addShutdownHook(final Runnable task) {
if (inEventLoop()) {
shutdownHooks.add(task);
} else {
execute(new Runnable() {
@Override
public void run() {
shutdownHooks.add(task);
}
});
}
}
/**
* Remove a previous added {@link Runnable} as a shutdown hook
*/
public void removeShutdownHook(final Runnable task) {
if (inEventLoop()) {
shutdownHooks.remove(task);
} else {
execute(new Runnable() {
@Override
public void run() {
shutdownHooks.remove(task);
}
});
}
}
private boolean runShutdownHooks() {
boolean ran = false;
// Note shutdown hooks can add / remove shutdown hooks.
while (!shutdownHooks.isEmpty()) {
List<Runnable> copy = new ArrayList<Runnable>(shutdownHooks);
shutdownHooks.clear();
for (Runnable task: copy) {
try {
task.run();
} catch (Throwable t) {
logger.warn("Shutdown hook raised an exception.", t);
} finally {
ran = true;
}
}
}
if (ran) {
lastExecutionTime = ScheduledFutureTask.nanoTime();
}
return ran;
}
//这里NioEventLoop关闭
@Override
public Future<?> shutdownGracefully(long quietPeriod, long timeout, TimeUnit unit) {
if (quietPeriod < 0) {
throw new IllegalArgumentException("quietPeriod: " + quietPeriod + " (expected >= 0)");
}
//判断是否设置关闭时间
if (timeout < quietPeriod) {
throw new IllegalArgumentException(
"timeout: " + timeout + " (expected >= quietPeriod (" + quietPeriod + "))");
}
if (unit == null) {
throw new NullPointerException("unit");
}
//判断是否是关闭状态,单个发起时候返回
if (isShuttingDown()) {
return terminationFuture();
}
boolean inEventLoop = inEventLoop();
boolean wakeup;
int oldState;
//多个应用线程发起并发执行，netty4中使用的是循环判断方式，也是自旋方式，也可以使用加锁的方式
for (;;) {
if (isShuttingDown()) {
return terminationFuture();
}
int newState;
wakeup = true;
oldState = state;
if (inEventLoop) {
newState = ST_SHUTTING_DOWN;
} else {
switch (oldState) {
case ST_NOT_STARTED:
case ST_STARTED:
newState = ST_SHUTTING_DOWN;
break;
default:
newState = oldState;
wakeup = false;
}
}
//写入新的状态值，这里没有写入继续循环写入，直到写入状态处于ST_SHUTTING_DOWN，ST_SHUTTING，ST_TERMINATED具体在isShuttingDown方法中
if (STATE_UPDATER.compareAndSet(this, oldState, newState)) {
break;
}
}
gracefulShutdownQuietPeriod = unit.toNanos(quietPeriod);
gracefulShutdownTimeout = unit.toNanos(timeout);
if (oldState == ST_NOT_STARTED) {
try {
doStartThread();
} catch (Throwable cause) {
STATE_UPDATER.set(this, ST_TERMINATED);
terminationFuture.tryFailure(cause);
if (!(cause instanceof Exception)) {
// Also rethrow as it may be an OOME for example
PlatformDependent.throwException(cause);
}
return terminationFuture;
}
}
if (wakeup) {
wakeup(inEventLoop);
}
return terminationFuture();
}
@Override
public boolean isShuttingDown() {
return state >= ST_SHUTTING_DOWN;
}
}
对closeAll实现分析，主要是把注册在selector上的所有Channel都关闭，具体在NioEventLoop类中代码如下：
private void closeAll() {
selectAgain();
Set<SelectionKey> keys = selector.keys();
Collection<AbstractNioChannel> channels = new ArrayList<AbstractNioChannel>(keys.size());
for (SelectionKey k: keys) {
Object a = k.attachment();
if (a instanceof AbstractNioChannel) {
channels.add((AbstractNioChannel) a);
} else {
k.cancel();
@SuppressWarnings("unchecked")
NioTask<SelectableChannel> task = (NioTask<SelectableChannel>) a;
invokeChannelUnregistered(task, k, null);
}
}
//将上边迭代出来的AbstractNioChannel逐个关闭
for (AbstractNioChannel ch: channels) {
//这里循环调用channel NioUnsafe的close方法，下面跳转到Unsafe中，对close方法进行分析
ch.unsafe().close(ch.unsafe().voidPromise());
}
}
持续往下close方法，AbstractChannel.AbstractUnsafe.close方法
private void close(final ChannelPromise promise, final Throwable cause,
final ClosedChannelException closeCause, final boolean notify) {
if (!promise.setUncancellable()) {
return;
}
if (closeInitiated) {
if (closeFuture.isDone()) {
// Closed already.
safeSetSuccess(promise);
} else if (!(promise instanceof VoidChannelPromise)) { // Only needed if no VoidChannelPromise.
// This means close() was called before so we just register a listener and return
closeFuture.addListener(new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
promise.setSuccess();
}
});
}
return;
}
closeInitiated = true;
final boolean wasActive = isActive();
final ChannelOutboundBuffer outboundBuffer = this.outboundBuffer;
//发送队列清空，不允许添加新的消息，刷新输出
this.outboundBuffer = null; // Disallow adding any messages and flushes to outboundBuffer.
Executor closeExecutor = prepareToClose();
if (closeExecutor != null) {
closeExecutor.execute(new Runnable() {
@Override
public void run() {
try {
// Execute the close.调用NioSocketChannel.doClose
doClose0(promise);
} finally {
// Call invokeLater so closeAndDeregister is executed in the EventLoop again!
invokeLater(new Runnable() {
@Override
public void run() {
if (outboundBuffer != null) {
// Fail all the queued messages
outboundBuffer.failFlushed(cause, notify);
outboundBuffer.close(closeCause);
}
fireChannelInactiveAndDeregister(wasActive);
}
});
}
}
});
} else {
try {
// Close the channel and fail the queued messages in all cases.
doClose0(promise);
} finally {
if (outboundBuffer != null) {
// Fail all the queued messages.
outboundBuffer.failFlushed(cause, notify);
outboundBuffer.close(closeCause);
}
}
//close前判断是否有消息正在发送，如果有则将SelectionKey的注册操作封装成Task放到eventLoop中稍后再执行
if (inFlush0) {
//稍后执行，先放入 eventLoop().execute(task);
invokeLater(new Runnable() {
@Override
public void run() {
fireChannelInactiveAndDeregister(wasActive);
}
});
} else {
fireChannelInactiveAndDeregister(wasActive);
}
}
}
//调用pipeline的fireChannelInactive，触发链路关闭通知事件。
private void fireChannelInactiveAndDeregister(final boolean wasActive) {
deregister(voidPromise(), wasActive && !isActive());
}
执行完资源释放和连接关闭后，通过上边的分析可以梳理下close方法过程。调用过程。
调试总结
- 是否有消息正在发送，将新来的注册操作挂起，包装成eventloop稍后执行，
- 将发送队列清空，不再允许发送新消息。
- 调用NioSocketChannel的doClose方法，关闭链路。javaChannel().close();
- 调用pipline的fireChannelInactive触发链路关闭通知事件
- 调用AbstractNioChannel的Deregister，从多路复用上取消selectionKey
- 调用ChannelOutboundBuffer的close方法，释放发送队列中所有未完成发送的ByteBuf，等待GC