前言：
集群之间的主节点与从节点之间实现数据的最终一致性。节点与节点之间实现数据的异步同步。节点与节点之间怎样才能感知对应节点状态。这就要求节点每隔一段时间定时的发送心跳包去感知对方的服务健康状态。一般在设置几个心跳包之后我们就可以认为对方节点已经挂了，我们就可以将该节点从集群中踢出去。

我们有个疑问，比如说之前的多客户端通信demo，当客户端断开与服务器连接的时候会触发handlerRemoved方法，那么我们就知道该服务的状态了。为什么还需要心跳包去感知呢？

真实情况远比我们想象中的复杂，比如我们的客户端是移动手机并且已经建立好了连接，当打开飞行模式（或者强制关机）的时候我们就无法感知当前连接已经断开了（handlerRemoved不会触发的），

当我们客户端和服务器端进行通信的时候，关闭网络或者打开飞行模式，此时通过handlerAdded方法和handlerRemoved是无法判断服务是否已经宕掉的。那么就引出了本文的内容。

什么是心跳检测？

判断对方（设备，进程或其它网元）是否正常动行，一般采用定时发送简单的通讯包，如果在指定时间段内未收到对方响应，则判断对方已经宕掉。用于检测TCP的异常断开。
基本原因是服务器端不能有效的判断客户端是否在线，也就是说服务器无法区分客户端是长时间在空闲，还是已经掉线的情况。所谓的心跳包就是客户端定时发送简单的信息给服务器端告诉它我还在而已。
代码就是每隔几分钟发送一个固定信息给服务端，服务端收到后回复一个固定信息。如果服务端几分钟内没有收到客户端信息则视客户端断开。比如有些通信软件长时间不使用，要想知道它的状态是在线还是离线就需要心跳包，定时发包收包。
发包方可以是客户也可以是服务端，看哪边实现方便合理。一般是客户端。服务器也可以定时轮询发心跳下去。
一般来说，出于效率的考虑，是由客户端主动向服务器端发包，而不是相反。
在分布式集群部署环境中也经常使用到心跳检测，比如主从服务之间的心跳检查，各master之间的互相检测等等，所以还是非常有实践意义的。

看一个实际开发中的心跳检测最简单的实践：

服务器端

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;


public class MyServer {
    public static void main(String[] args) throws Exception{
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup wokerGroup = new NioEventLoopGroup();

        try{
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup,wokerGroup).channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new MyServerInitializer());

            ChannelFuture channelFuture = serverBootstrap.bind(8899).sync();
            channelFuture.channel().closeFuture().sync();
        }finally {
            bossGroup.shutdownGracefully();
            wokerGroup.shutdownGracefully();
        }
    }
}

服务器端Initializer

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.timeout.IdleStateHandler;

import java.util.concurrent.TimeUnit;

public class MyServerInitializer extends ChannelInitializer<SocketChannel>{

    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();

        //处理空闲状态事件的处理器
        pipeline.addLast(new IdleStateHandler(5,7,10, TimeUnit.SECONDS));
        //对空闲检测进一步处理的Handler
        pipeline.addLast(new MyServerHandler());
    }
}

• 定义的服务器端读事件的时间，当客户端5s时间没有往服务器写数据（服务器端就是读操作）则触发IdleStateEvent事件。
• 服务器端写事件的时间，当服务器端7s的时间没有向客户端写数据，则触发IdleStateEvent事件。
• 当客户端没有往服务器端写数据和服务器端没有往客户端写数据10s的时间，则触发IdleStateEvent事件。

自定义处理器服务器Handler：

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.timeout.IdleStateEvent;

/**
 * 定义的MyServerHandler没有去继承 SimpleChannelInboundHandler，而是继承
 * SimpleChannelInboundHandler的父类ChannelInboundHandlerAdapter
 */
public class MyServerHandler extends ChannelInboundHandlerAdapter{

    //管道中上一个Handler触发的事件
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        IdleStateEvent event =(IdleStateEvent)evt;

        String eventType = null;

        switch (event.state()){
            case READER_IDLE:
                eventType = "读空闲";
                break;
            case WRITER_IDLE:
                eventType = "写空闲";
                break;
            case ALL_IDLE:
                eventType ="读写空闲";
                break;
        }

        System.out.println(ctx.channel().remoteAddress() + "超时事件：" +eventType);

        ctx.channel().close();
    }
}

客户端：

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class MyChatClient {
    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 MyChatClientInitializer());

            Channel channel = bootstrap.connect("localhost",8899).sync().channel();

            //标准输入
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

            //利用死循环，不断读取客户端在控制台上的输入内容
            for (;;){
                channel.writeAndFlush(bufferedReader.readLine() +"\r\n");
            }

        }finally {
            eventLoopGroup.shutdownGracefully();
        }
    }
}

测试：

启动服务器和客户端，当5s后客户端没有往服务端写数据，造成了服务器端读空闲，服务器的控制台上打印：

十月 13, 2017 12:41:55 上午 io.netty.handler.logging.LoggingHandler channelRead
信息: [id: 0x38081a23, L:/0:0:0:0:0:0:0:0:8899] READ: [id: 0x6d059808, L:/127.0.0.1:8899 - R:/127.0.0.1:57561]
十月 13, 2017 12:41:55 上午 io.netty.handler.logging.LoggingHandler channelReadComplete
信息: [id: 0x38081a23, L:/0:0:0:0:0:0:0:0:8899] READ COMPLETE
/127.0.0.1:57561超时事件：读空闲

修改服务器端Initializer中的代码：

pipeline.addLast(new IdleStateHandler(5,3,10, TimeUnit.SECONDS));

重启服务器和客户端，当服务器端3s没有往客户端写数据，则造成服务器的写空闲。服务器端控制台打印：

十月 13, 2017 12:44:43 上午 io.netty.handler.logging.LoggingHandler bind
信息: [id: 0x12eb2eca] BIND: 0.0.0.0/0.0.0.0:8899
十月 13, 2017 12:44:43 上午 io.netty.handler.logging.LoggingHandler channelActive
信息: [id: 0x12eb2eca, L:/0:0:0:0:0:0:0:0:8899] ACTIVE
十月 13, 2017 12:44:49 上午 io.netty.handler.logging.LoggingHandler channelRead
信息: [id: 0x12eb2eca, L:/0:0:0:0:0:0:0:0:8899] READ: [id: 0x8547406c, L:/127.0.0.1:8899 - R:/127.0.0.1:57592]
十月 13, 2017 12:44:49 上午 io.netty.handler.logging.LoggingHandler channelReadComplete
信息: [id: 0x12eb2eca, L:/0:0:0:0:0:0:0:0:8899] READ COMPLETE
/127.0.0.1:57592超时事件：写空闲

修改服务器端Initializer中的代码：

 pipeline.addLast(new IdleStateHandler(5,7,4, TimeUnit.SECONDS));

当客户端没有往服务器写数据（造成服务器读事件）和服务端没有往客户端写数据（造成服务器端写事件）的时间达到4s则触发服务端读写空闲。
重启客户端和服务器服务，4s后服务器端控制台打印：

十月 13, 2017 12:47:52 上午 io.netty.handler.logging.LoggingHandler bind
信息: [id: 0x8bb2c1a5] BIND: 0.0.0.0/0.0.0.0:8899
十月 13, 2017 12:47:52 上午 io.netty.handler.logging.LoggingHandler channelActive
信息: [id: 0x8bb2c1a5, L:/0:0:0:0:0:0:0:0:8899] ACTIVE
十月 13, 2017 12:47:57 上午 io.netty.handler.logging.LoggingHandler channelRead
信息: [id: 0x8bb2c1a5, L:/0:0:0:0:0:0:0:0:8899] READ: [id: 0x49a9006e, L:/127.0.0.1:8899 - R:/127.0.0.1:57622]
十月 13, 2017 12:47:57 上午 io.netty.handler.logging.LoggingHandler channelReadComplete
信息: [id: 0x8bb2c1a5, L:/0:0:0:0:0:0:0:0:8899] READ COMPLETE
/127.0.0.1:57622超时事件：读写空闲