面试题：网络编程Netty自定义TCP连接关闭逻辑的深度优化

设计思路

明确需求：在高并发、低延迟场景下，快速且稳定地关闭TCP连接。需要考虑连接关闭时的优雅性，即等待未处理完的业务逻辑执行完毕，同时避免长时间阻塞影响整体性能。
基于事件驱动：Netty是事件驱动的框架，利用其提供的ChannelHandler来处理连接关闭相关事件。在ChannelInboundHandler中监听连接关闭事件，在ChannelOutboundHandler中处理关闭连接的操作。
分离业务与关闭逻辑：将业务处理逻辑与连接关闭逻辑解耦，确保关闭逻辑不会对正常业务流程造成干扰，提高代码的可维护性。

关键实现点

自定义ChannelHandler：

继承ChannelInboundHandlerAdapter：重写channelInactive方法，此方法在连接被关闭时触发。在这里可以做一些资源清理、记录日志等操作。

public class CustomInboundHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        // 记录连接关闭日志
        System.out.println("Connection closed: " + ctx.channel());
        // 释放与该连接相关的业务资源
        super.channelInactive(ctx);
    }
}

继承ChannelOutboundHandlerAdapter：重写close方法，在此方法中实现主动关闭连接的逻辑，并且可以进行一些前置检查，如是否有未完成的任务。

public class CustomOutboundHandler extends ChannelOutboundHandlerAdapter {
    @Override
    public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
        // 检查是否有未完成的业务任务
        // 如果有，等待或采取相应策略
        ctx.close(promise);
    }
}

添加到ChannelPipeline：在ServerBootstrap或Bootstrap配置时，将自定义的ChannelHandler添加到ChannelPipeline中。

ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
 .channel(NioServerSocketChannel.class)
 .childHandler(new ChannelInitializer<SocketChannel>() {
      @Override
      protected void initChannel(SocketChannel ch) throws Exception {
          ChannelPipeline p = ch.pipeline();
          p.addLast(new CustomInboundHandler());
          p.addLast(new CustomOutboundHandler());
      }
  });

优雅关闭：在关闭连接前，处理未完成的业务任务。可以使用EventExecutorGroup来管理任务执行，确保任务在连接关闭前执行完毕。例如，将未完成的任务提交到一个ScheduledExecutorService中，设置一个合理的超时时间，在超时后强制关闭连接。

public class CustomOutboundHandler extends ChannelOutboundHandlerAdapter {
    private final ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
    @Override
    public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
        // 检查并处理未完成任务
        Future<?> future = executor.submit(() -> {
            // 处理未完成业务逻辑
        });
        executor.schedule(() -> {
            if (!future.isDone()) {
                // 超时处理，强制关闭连接
                ctx.close(promise);
            }
        }, 5, TimeUnit.SECONDS);
    }
}

性能优化

减少锁的使用：在高并发场景下，锁的竞争会导致性能下降。在处理连接关闭逻辑时，尽量避免使用锁，或者使用更细粒度的锁。例如，在处理连接相关的资源清理时，如果资源之间没有共享关系，可以分别处理，而不使用锁来同步。

异步处理：利用Netty的异步特性，将一些耗时操作（如日志记录、资源持久化等）异步化。通过EventLoop将这些操作提交到后台线程池中执行，避免阻塞主线程，从而降低延迟。

public class CustomInboundHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        ctx.channel().eventLoop().execute(() -> {
            // 异步记录日志
            System.out.println("Connection closed: " + ctx.channel());
        });
        super.channelInactive(ctx);
    }
}

连接复用：在业务允许的情况下，尽量复用TCP连接，减少频繁的连接创建和关闭操作。可以通过连接池技术来管理连接，提高连接的利用率，从而提升整体性能。

避免内存泄漏和资源耗尽

资源及时释放：在连接关闭时，确保所有与该连接相关的资源（如缓冲区、文件句柄、线程等）都被正确释放。在channelInactive方法中，对使用到的资源进行清理。例如，如果使用了直接内存缓冲区（DirectByteBuffer），需要调用ByteBuffer#release方法释放内存。

public class CustomInboundHandler extends ChannelInboundHandlerAdapter {
    private ByteBuffer buffer;
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        if (buffer != null && buffer.isDirect()) {
            ((DirectBuffer) buffer).release();
        }
        super.channelInactive(ctx);
    }
}

线程管理：如果在连接关闭逻辑中使用了线程，要确保线程正确终止，避免线程泄漏。对于自定义的线程，在线程执行完毕后，及时调用Thread#interrupt方法中断线程，并在finally块中进行资源清理。对于线程池，在连接关闭时，调用ExecutorService#shutdown和ExecutorService#awaitTermination方法，确保所有任务执行完毕后关闭线程池。

public class CustomOutboundHandler extends ChannelOutboundHandlerAdapter {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();
    @Override
    public void close(ChannelHandlerContext ctx, ChannelPromise promise) throws Exception {
        try {
            Future<?> future = executor.submit(() -> {
                // 处理未完成业务逻辑
            });
            future.get(5, TimeUnit.SECONDS);
        } catch (Exception e) {
            // 处理异常
        } finally {
            executor.shutdown();
            try {
                if (!executor.awaitTermination(5, TimeUnit.SECONDS)) {
                    executor.shutdownNow();
                }
            } catch (InterruptedException ie) {
                executor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }
        ctx.close(promise);
    }
}

连接跟踪：使用一个连接管理器来跟踪所有活动的连接，在连接关闭时，从管理器中移除该连接。这样可以避免在内存中残留无用的连接对象，防止内存泄漏。同时，通过连接管理器可以监控连接的数量，当连接数量达到一定阈值时，进行相应的处理，如限制新连接的创建，避免资源耗尽。

public class ConnectionManager {
    private static final Set<Channel> activeConnections = Collections.synchronizedSet(new HashSet<>());
    public static void addConnection(Channel channel) {
        activeConnections.add(channel);
    }
    public static void removeConnection(Channel channel) {
        activeConnections.remove(channel);
    }
    public static int getConnectionCount() {
        return activeConnections.size();
    }
}

在ChannelInitializer中添加连接跟踪逻辑：

ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
 .channel(NioServerSocketChannel.class)
 .childHandler(new ChannelInitializer<SocketChannel>() {
      @Override
      protected void initChannel(SocketChannel ch) throws Exception {
          ChannelPipeline p = ch.pipeline();
          p.addLast(new ChannelInboundHandlerAdapter() {
              @Override
              public void channelActive(ChannelHandlerContext ctx) throws Exception {
                  ConnectionManager.addConnection(ctx.channel());
                  super.channelActive(ctx);
              }
              @Override
              public void channelInactive(ChannelHandlerContext ctx) throws Exception {
                  ConnectionManager.removeConnection(ctx.channel());
                  super.channelInactive(ctx);
              }
          });
      }
  });

星途面试题库

面试题：网络编程Netty自定义TCP连接关闭逻辑的深度优化

知识考点

面试题答案

设计思路

关键实现点

性能优化

避免内存泄漏和资源耗尽