public IdleStateHandler(long readerIdleTime, long writerIdleTime, long allIdleTime, TimeUnit unit)

package com.artisan.heartbeat;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.timeout.IdleStateHandler;
import java.util.concurrent.TimeUnit;
/**
 * @author маленький мастер
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class HeartBeatArtisanServer {
    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) // использоватьNioServerSocketChannel в качестве канала
                    .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()); // Добавить кодировщик
                            // Добавьте процессор состояния простоя и установите время простоя чтения на 3 секунды.
                            pipeline.addLast(new IdleStateHandler(3, 0, 0, TimeUnit.SECONDS));
                            pipeline.addLast(new HeartBeatArtisanServerHandler()); // Добавить собственный процессор
                        }
                    });
            System.out.println("netty server start。。"); // Распечатать информацию о запуске
            // Привяжите порт и синхронно ждите успеха
            ChannelFuture future = bootstrap.bind(9000).sync();
            // Подождите, пока сокет сервера закроется
            future.channel().closeFuture().sync();
        } catch (Exception e) {
            e.printStackTrace(); // Распечатать информацию об исключении
        } finally {
            // Освободите ресурсы и корректно закройте группу цикла событий.
            worker.shutdownGracefully();
            boss.shutdownGracefully();
        }
    }
}

package com.artisan.heartbeat;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.timeout.IdleStateEvent;
/**
 * @author маленький мастер
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class HeartBeatArtisanServerHandler extends SimpleChannelInboundHandler<String> {
    // Определите счетчик для записи количества неактивных операций чтения.
    int readIdleTimes = 0;
    // Этот метод будет вызываться при чтении сообщения из канала.
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String s) throws Exception {
        System.out.println(" ====== > [server] message received : " + s);
        // Если из сообщения да"Heartbeat получено Пакет", затем ответьте "ок"
        if ("Heartbeat Packet".equals(s)) {
            ctx.channel().writeAndFlush("ok");
        } else {
            // Если да другая информация, выведите другую информацию обработки. ...
            System.out.println(" Другая обработка информации ... ");
        }
    }
    // Этот метод будет вызываться, когда Netty инициирует тайм-аут.
    @Override
    public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
        IdleStateEvent event = (IdleStateEvent) evt;
        // Определяет строку, используемую для хранения типа события тайм-аута.
        String eventType = null;
        // Переключение в зависимости от статуса события
        switch (event.state()) {
            case READER_IDLE:
                eventType = «Читать вхолостую»;
                // Чтение простоя с увеличением счетчика на 1
                readIdleTimes++; 
                break;
            case WRITER_IDLE:
                eventType = «Пиши без дела»;
                // Не обработано
                break;
            case ALL_IDLE:
                eventType = «Чтение и запись в режиме ожидания»;
                // Не обработано
                break;
        }
        
        // Распечатайте информацию о тайм-ауте
        System.out.println(ctx.channel().remoteAddress() + "тайм-аутсобытие：" + eventType);
        // Если количество простоев чтения превышает 3 раза, закройте соединение, чтобы освободить больше ресурсов.
        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 ===");
    }
}

package com.artisan.heartbeat;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import java.util.Random;
/**
 * @author маленький мастер
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class HeartBeatArtisanClient {
    public static void main(String[] args) throws Exception {
        // Создайте NioEventLoopGroup для обработки циклов Nettyизсобытие.
        EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
        try {
            // Создайте объект Bootstrap для настройки клиента.
            Bootstrap bootstrap = new Bootstrap();
            // Установите типы EventLoopGroup и Channel.
            bootstrap.group(eventLoopGroup).channel(NioSocketChannel.class)
                    // Добавьте ChannelInitializer для инициализации ChannelPipeline.
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            // получатьChannelPipelineи Добавить декодер, кодер и обработчик обработки пульса
                            ChannelPipeline pipeline = ch.pipeline();
                            pipeline.addLast("decoder", new StringDecoder());
                            pipeline.addLast("encoder", new StringEncoder());
                            pipeline.addLast(new HeartBeatArtisanClientHandler());
                        }
                    });
            // Распечатайте информацию о запуске клиента Netty.
            System.out.println("netty client start。。");
            // подключиться к серверу и получить объект Channel
            Channel channel = bootstrap.connect("127.0.0.1", 9000).sync().channel();
            // Определите текст отправляемого пакета Heartbeat.
            String text = "Heartbeat Packet";
            // Создайте объект Random для генерации случайных чисел.
            Random random = new Random();
            // существующий случайный отправляет пакеты пульса в цикле
            while (channel.isActive()) {
                int num = random.nextInt(8);
                Thread.sleep(num * 1000);
                channel.writeAndFlush(text);
            }
        } catch (Exception e) {
            // Распечатать информацию об исключении
            e.printStackTrace();
        } finally {
            // Грамотно закройте EventLoopGroup и освободите ресурсы.
            eventLoopGroup.shutdownGracefully();
        }
    }
    
}

package com.artisan.heartbeat;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
/**
 * @author маленький мастер
 * @version 1.0
 * @mark: show me the code , change the world
 */
public class HeartBeatArtisanClientHandler extends SimpleChannelInboundHandler<String> {
    // Переопределить метод ChannelRead0 для обработки получения сообщений.
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
        // Распечатать полученное сообщение
        System.out.println(" client received :" + msg);
        // Если получено сообщение да"idle закрыть", затем закрыть соединение
        if (msg != null && msg.equals("idle close")) {
            // Распечатайте информацию об отключении сервера
            System.out.println(" Сервер закрыт соединять и клиент тоже закрыт");
            // Закрыть клиентсоединять
            ctx.channel().closeFuture();
        }
    }
}

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) {
            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);
        }
    }

 if (readerIdleTimeNanos > 0) {
            readerIdleTimeout = schedule(ctx, new ReaderIdleTimeoutTask(ctx),
                    readerIdleTimeNanos, TimeUnit.NANOSECONDS);
        }

@Override
        protected void run(ChannelHandlerContext ctx) {
            // Определите время задержки перед переходом в состояние ожидания в следующий раз.
            long nextDelay = readerIdleTimeNanos;
            // Если текущий статус не читается
            if (!reading) {
                // Вычтите количество наносекунд с момента последнего чтения, чтобы настроить следующую задержку.
                nextDelay -= ticksInNanos() - lastReadTime;
            }

            // Если время задержки меньше или равно 0, это означает, что чтение бездействовало достаточно долгое время.
            if (nextDelay <= 0) {
                // Установите новый тайм-аут и отправьте уведомление об обратном вызове
                readerIdleTimeout = schedule(ctx, this, readerIdleTimeNanos, TimeUnit.NANOSECONDS);

                // да Нода Первый триггер читается в режиме ожиданиясобытие
                boolean first = firstReaderIdleEvent;
                firstReaderIdleEvent = false; // Установите флаг в значение false, чтобы избежать повторного срабатывания последующих

                try {
                    // Создать событие состояния простоя
                    IdleStateEvent event = newIdleStateEvent(IdleState.READER_IDLE, first);
                    // существуют, вызывают это событие в контексте канала
                    channelIdle(ctx, event);
                } catch (Throwable t) {
                    // Если возникает исключение, распространите это исключение на контекст канала.
                    ctx.fireExceptionCaught(t);
                }
            } else {
                // Если операция чтения происходит до истечения времени существования, запланируйте более короткую задержку по времени ожидания.
                readerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);
            }
        }
    }

nextDelay -= ticksInNanos() - lastReadTime;

    /**
     * Is called when an {@link IdleStateEvent} should be fired. This implementation calls
     * {@link ChannelHandlerContext#fireUserEventTriggered(Object)}.
     */
    protected void channelIdle(ChannelHandlerContext ctx, IdleStateEvent evt) throws Exception {
        ctx.fireUserEventTriggered(evt);
    }

// Если операция чтения происходит до истечения времени существования, запланируйте более короткую задержку по времени ожидания.
readerIdleTimeout = schedule(ctx, this, nextDelay, TimeUnit.NANOSECONDS);