【Netty】IdleStateHandler 心跳检测，实现超时断开连接
通过前面几篇博客的各种代码示例，就算别的没记住，也应该对实验后 Client 不会自动断开连接，等手动关闭时会报错的情况应该印象很深把。因为 Netty 建立的是长连接，也就是说只要不在 Client 的代码中手动 channel.close(); 那该连接就会一直保持着，直到客户端或者服务器一方关闭。
也不是说长连接它就不好，但大家想想，每一个客户端都一直占着一个连接，即使它后面已经用不到服务器了，而服务器能承受的连接数是有限的，后面再来了真正有需求的用户，它也进不来了，而且长时间的高并发也可能导致服务器宕机。
所以，有没有一种办法，如果我一段时间用不到服务器，就把这个连接给关掉？答：心跳机制。所谓心跳，即在 TCP 长连接中，客户端和服务器之间定期发送的一种特殊的数据包（比如消息内容是某种要求格式、内容），通知对方自己还在线，以确保 TCP 连接的有效性。
在 Netty 中，实现心跳机制的关键是 IdleStateHandler（空闲状态处理器），它的作用跟名字一样，是用来监测连接的空闲情况。然后我们就可以根据心跳情况，来实现具体的处理逻辑，比如说断开连接、重新连接等等。
那么，这篇文章的思路有了！我们先来分析 IdleStateHandler 为什么能实现心跳检测，然后再看看如何编写 Server 处理逻辑…
1.IdleStateHandler 原理
我们先来看一下 IdleStateHandler 的继承关系：
可以看到它也是一个 ChannelHandler，并且还是个 ChannelInboundHandler，是用来处理入站事件的。看下它的构造器：
public IdleStateHandler(
int readerIdleTimeSeconds,
int writerIdleTimeSeconds,
int allIdleTimeSeconds) {
this(readerIdleTimeSeconds, writerIdleTimeSeconds, allIdleTimeSeconds,
TimeUnit.SECONDS);
}
这里解释下三个参数的含义：
- readerIdleTimeSeconds：读超时。即当在指定的时间间隔内没有从 Channel 读取到数据时，会触发一个 READER_IDLE 的 IdleStateEvent 事件
- writerIdleTimeSeconds: 写超时。即当在指定的时间间隔内没有数据写入到 Channel 时，会触发一个 WRITER_IDLE 的 IdleStateEvent 事件
- allIdleTimeSeconds: 读/写超时。即当在指定的时间间隔内没有读或写操作时，会触发一个 ALL_IDLE 的 IdleStateEvent 事件
所以，跟编解码码器这些 ChannelHandler 一样，要实现 Netty 服务端心跳检测机制，也需要将 IdleStateHandler 注册到服务器端的 ChannelInitializer 中：
// 由于我们的需求是判断 Client 时候还要向 Server 发送请求，从而决定是否关闭该连接
// 所以，我们只需要判断 Server 是否在时间间隔内从 Channel 读取到数据
// 所以，readerIdleTimeSeconds 我们取 3s，而 writerIdleTimeSeconds 为 0
pipeline.addLast(new IdleStateHandler(3, 0, 0));
PS：这三个参数默认的时间单位是秒。若需要指定其他时间单位，可以使用另一个构造方法： public IdleStateHandler(boolean observeOutput,long readerIdleTime, long writerIdleTime, long allIdleTime,TimeUnit unit)
IdleStateHandler 源码分析
初步地看下 IdleStateHandler 源码，先看下 IdleStateHandler 中的 channelRead 方法：
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (readerIdleTimeNanos > 0 || allIdleTimeNanos > 0) {
reading = true;
firstReaderIdleEvent = firstAllIdleEvent = true;
}
// 该方法只是进行了透传，不做任何业务逻辑处理，
// 让 channelPipe 中的下一个 handler 处理 channelRead 方法
ctx.fireChannelRead(msg);
}
我们再看看 channelActive 方法：
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
// This method will be invoked only if this handler was added
// before channelActive() event is fired. If a user adds this handler
// after the channelActive() event, initialize() will be called by beforeAdd().
initialize(ctx);
super.channelActive(ctx);
}
这里有个 initialize 方法，这是IdleStateHandler的精髓，接着探究：
private void initialize(ChannelHandlerContext ctx) {
// Avoid the case where destroy() is called before scheduling timeouts.
// See: https://github.com/netty/netty/issues/143
switch (state) {
case 1:
case 2:
return;
}
state = 1;
initOutputChanged(ctx);
lastReadTime = lastWriteTime = ticksInNanos();
// 根据读超时、写超时、读写超时创建定时任务
if (readerIdleTimeNanos > 0) {
// schedule 方法其实调用的线程池
readerIdleTimeout = schedule(ctx, new ReaderIdleTimeoutTask(ctx),
readerIdleTimeNanos, TimeUnit.NANOSECONDS);
}
if (writerIdleTimeNanos > 0) {
writerIdleTimeout = schedule(ctx, new WriterIdleTimeoutTask(ctx),
writerIdleTimeNanos, TimeUnit.NANOSECONDS);
}
if (allIdleTimeNanos > 0) {
allIdleTimeout = schedule(ctx, new AllIdleTimeoutTask(ctx),
allIdleTimeNanos, TimeUnit.NANOSECONDS);
}
}
由于我们在上面创建 IdleStateHandler 时只是指定了 readerIdleTimeNanos=3，所以只会这里只会创建 ReaderIdleTimeoutTask。
PS：当线程池要执行某个 Task 时，实际就是让工作线程去执行 Task 的 run 方法。
那么，我们下面就来看看 ReaderIdleTimeoutTask 这个 Task 里的 run 方法：
@Override
protected void run(ChannelHandlerContext ctx) {
long nextDelay = readerIdleTimeNanos;
if (!reading) {
// nextDelay 等于用当前时间减去最后一次 channelRead 方法调用的时间
// 假如这个结果是 4s，说明最后一次调用 channelRead 已经是4s之前的事情了
nextDelay -= ticksInNanos() - lastReadTime;
}
// 假如这个结果是 4s，说明最后一次调用 channelRead 已经是4s之前的事情了
// 而上面我们设置的是读超时为3s，那么nextDelay则为-1，说明超时了
if (nextDelay <= 0) {
// Reader is idle - set a new timeout and notify the callback.
// 重置定时任务，将delay设为 3s
readerIdleTimeout = schedule(ctx, this, readerIdleTimeNanos, TimeUnit.NANOSECONDS);
boolean first = firstReaderIdleEvent;
firstReaderIdleEvent = false;
try {
IdleStateEvent event = newIdleStateEvent(IdleState.READER_IDLE, first);
// 核心！！
// channelIdle 实际调用的是 ctx.fireUserEventTriggered(evt)
// 触发下一个 handler 的 UserEventTriggered 方法
channelIdle(ctx, event);
} catch (Throwable t) {
ctx.fireExceptionCaught(t);
}
// 假如这个结果是 2s，说明最后一次调用 channelRead 已经是2s之前的事情了
// 而上面我们设置的是读超时为3s，那么nextDelay则为1，说明没超时
} else {
// Read occurred before the timeout - set a new timeout with shorter delay.
// 重置定时任务，将delay设为 1
readerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);
}
}
上面的代码中两次重置 schedule 相当于循环，不断的更新定时时间(delay)
- 如果读超时了，就重置 delay 为初始值，并进入 UserEventTriggered() 用户自定义的处理逻辑中
- 如果没有读超时，就更新 delay 为一个更小的值
至此我们将 IdleStateHandler 底层核心逻辑分析完了，但 IdleStateHandler 说到底也只是能做一个空闲状态监测，但是根据连接空闲情况关闭连接等逻辑还要我们自己实现。下面我们就来看看怎么做…
2.心跳检测 -> 断开连接
HeartBeatServer
public class HeartBeatServer {
public static void main(String[] args) throws Exception {
EventLoopGroup boss = new NioEventLoopGroup();
EventLoopGroup worker = new NioEventLoopGroup();
try {
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.group(boss, worker)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
// IdleStateHandler 的 readerIdleTime 参数指定超过3秒还没收到客户端的连接，
// 会触发 IdleStateEvent 事件并且交给下一个 handler 处理，
// 下一个 handler 必须实现 userEventTriggered 方法处理对应事件
pipeline.addLast(new IdleStateHandler(3, 0, 0));
// 所以，HeartBeatServerHandler 必须要有实现 userEventTriggered 方法
pipeline.addLast(new HeartBeatServerHandler());
}
});
ChannelFuture future = bootstrap.bind(9000).sync();
System.out.println("Netty Server started...");
future.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
} finally {
worker.shutdownGracefully();
boss.shutdownGracefully();
}
}
}
HeartBeatServerHandler（核心）
public class HeartBeatServerHandler extends SimpleChannelInboundHandler<String> {
// 记录读超时几次了，用来判断是否断开该连接
int readIdleTimes = 0;
/*
* Channel 收到消息后触发
*
* 注：心跳包说白了就是一个某些地方特殊的数据包
* 所以这里我们规定，如果消息内容是 "Heartbeat Packet"，那么它就是一个心跳包
*/
@Override
protected void channelRead0(ChannelHandlerContext ctx, String s) throws Exception {
// 将收到的消息打印出来
System.out.println(" ====== > [server] message received : " + s);
// 如果消息内容是 Heartbeat Packet 则说明这是一个心跳包，我们返回 ok
if ("Heartbeat Packet".equals(s)) {
ctx.channel().writeAndFlush("ok");
// 其余情况说明收到的是一个正常消息，不做特殊处理
} else {
System.out.println(" 其他信息处理 ... ");
}
}
/**
* 用户事件触发
*
* 当 IdleStateHandler 发现读超时后，会调用 fireUserEventTriggered() 去执行后一个 Handler 的 userEventTriggered 方法。
* 所以，根据心跳检测状态去关闭连接的就写在这里！
*/
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
IdleStateEvent event = (IdleStateEvent) evt;
String eventType = null;
// 我们在 IdleStateHandler 中也看到了，它有读超时，写超时，读写超时等
// 所以，这里我们需要判断事件类型
switch (event.state()) {
case READER_IDLE:
eventType = "读空闲";
readIdleTimes++; // 读空闲的计数加 1
break;
case WRITER_IDLE:
eventType = "写空闲";
break; // 不处理
case ALL_IDLE:
eventType = "读写空闲";
break; // 不处理
}
// 打印触发了一次超时警告
System.out.println(ctx.channel().remoteAddress() + "超时事件：" + eventType);
// 当读超时超过 3 次，我们就端口该客户端的连接
// 注：读超时超过 3 次，代表起码有 4 次 3s 内客户端没有发送心跳包或普通数据包
if (readIdleTimes > 3) {
System.out.println(" [server]读空闲超过3次，关闭连接，释放更多资源");
ctx.channel().writeAndFlush("idle close");
ctx.channel().close(); // 断开连接
}
}
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.err.println("=== " + ctx.channel().remoteAddress() + " is active ===");
}
}
HeartBeatClient
public class HeartBeatClient {
public static void main(String[] args) throws Exception {
EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
try {
Bootstrap bootstrap = new Bootstrap();
bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());
pipeline.addLast(new HeartBeatClientHandler());
}
});
Channel channel = bootstrap.connect("127.0.0.1", 9000).sync().channel();
System.out.println("Netty Client started...");
// 心跳包内容
String text = "Heartbeat Packet";
Random random = new Random();
// 随机休眠 10s 内的时间，然后发送心跳包
// 也就是说，如果 num>3，那么就会触发一次Server的超时警告
// 也就是说，如果 num>3 出现 4 次时，该连接就被 Server 强制关闭了
// 也就是说，如果所有心跳包都能在 3s 内发送，那么连接就可以一直保持
// 注：正因为 random，所以每次运行 Client 的结果是不确定的
while (channel.isActive()) {
int num = random.nextInt(10);
Thread.sleep(num * 1000);
channel.writeAndFlush(text);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
eventLoopGroup.shutdownGracefully();
}
}
static class HeartBeatClientHandler extends SimpleChannelInboundHandler<String> {
@Override
protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
System.out.println(" client received :" + msg);
if (msg != null && msg.equals("idle close")) {
System.out.println(" 服务端关闭连接，客户端也关闭");
ctx.channel().closeFuture();
}
}
}
}
好了，我们把 Server、Client 运行一下看看
注：由于客户端设置的发送心跳包时间是随机的（[0,10]），所以多个 Client 的运行结果可能不同
总结
正是因为 Netty 封装了真么多功能丰富，稳定可靠的 Handler，所以 Dubbo 等 Rpc 框架，Zookeeper、Eureka 等中间件才会在底层 IO 采用它。就拿本篇的 IdleStateHandler 来说，有了它我们就很容易实现心跳监控连接情况，并做出相应处理，如果感兴趣的同学可以看看 zk 底层心跳机制的实现，它就是这样做的。