0
0

深入netty22-netty性能优化和最佳实践

网络参数优化

在网络编程中，性能优化是一个重要的议题

SO_SNDBUF 和 SO_RCVBUF

  • 作用：分别代表 TCP 发送缓冲区和接收缓冲区的大小。
  • 优化：根据网络条件（如带宽和延迟）来设置缓冲区大小，以避免缓冲区成为通信瓶颈。
  • 内存使用：建议根据消息的平均大小而非最大消息大小来设置缓冲区大小，以减少内存浪费。
  • 动态调整：使用 Netty 的 AdaptiveRecvByteBufAllocator 可以动态调整接收缓冲区的大小，以适应不同的网络条件。

TCP_NODELAY

  • 作用：控制是否启用 Nagle 算法，该算法通过缓冲小的数据包来减少网络传输次数。
  • 优化：在对延迟敏感的应用中，禁用 Nagle 算法（设置 TCP_NODELAY 为 true）可以减少数据包传输的延迟。

SO_BACKLOG

  • 作用：定义已完成三次握手的请求队列的最大长度。
  • 优化：在高并发场景下，适当增加 SO_BACKLOG 的值可以处理更多的并发连接，但也要避免过大的值以防止 SYN-Flood 攻击。

SO_KEEPALIVE

  • 作用：控制 TCP 连接保活机制，定期发送心跳包以检测连接状态。
  • 优化：在需要确保连接活性的场景中启用，但要注意这可能会引入额外的延迟。

Linux 系统参数优化

  • 文件句柄数：在海量连接的场景下，操作系统的文件句柄限制可能会成为瓶颈。
  • 优化：通过修改 /etc/security/limits.conf 文件和执行 sysctl -p 命令来增加最大文件句柄数。
  • 命令：* soft nofile 1000000 * hard nofile 1000000
  • 验证：使用 ulimit -a 命令来查看参数是否生效。

Netty 网络参数示例

在 Netty 中，可以通过 

ChannelOption

设置这些参数：

ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
 .channel(NioServerSocketChannel.class)
 .option(ChannelOption.SO_BACKLOG, 128)
 .option(ChannelOption.SO_KEEPALIVE, true)
 .option(ChannelOption.TCP_NODELAY, true)
 .option(ChannelOption.SO_SNDBUF, 1024)
 .option(ChannelOption.SO_RCVBUF, 1024)
 .childHandler(new ChannelInitializer<SocketChannel>() {
     @Override
     public void initChannel(SocketChannel ch) {
         ch.pipeline().addLast(new MyServerHandler());
     }
 });
ChannelFuture f = b.bind(8080).sync();

在这个示例中，我们设置了服务器启动参数，包括 

SO_BACKLOG

、

SO_KEEPALIVE

和 

TCP_NODELAY

，以及发送和接收缓冲区的大小。通过这些优化，可以显著提高网络应用的性能，特别是在高并发和高吞吐量的场景中。然而，每个参数的最优设置取决于具体的应用场景和网络环境，因此在应用这些优化时，应该根据实际情况进行测试和调整。

业务线程池优化

在 Netty 中，使用业务线程池（也称为工作线程池）来处理耗时任务是一个推荐的做法，原因如下：

  1. 避免阻塞 I/O 线程：- Netty 的事件循环线程（I/O 线程）主要用于处理网络 I/O 事件，如连接建立、数据读写等。这些线程的资源是有限的，如果被耗时的操作阻塞，将无法处理其他事件，从而影响网络性能。
  2. 提高系统吞吐量：- 通过将耗时任务（如业务逻辑处理、数据库访问、远程服务调用等）提交到业务线程池，可以让 I/O 线程尽快释放回循环，继续处理其他任务。这样可以提高系统的并发处理能力和吞吐量。
  3. 资源隔离：- 业务线程池可以根据业务需求独立配置，例如线程数量、队列大小等。这有助于隔离不同业务之间的资源竞争，避免相互影响。
  4. 灵活性和扩展性：- 使用业务线程池可以根据业务逻辑的复杂度和执行时间灵活调整线程资源，同时也方便在系统扩展时对资源进行水平扩展。
  5. 错误隔离：- 在业务线程池中处理耗时任务可以将错误和异常局限在特定的线程范围内，避免影响到整个 I/O 线程的稳定性。
  6. 简化 I/O 线程的职责：- 保持 I/O 线程的职责简单，专注于网络事件的处理，而将复杂的业务逻辑交给业务线程池处理，有助于降低系统的复杂度。

在 Netty 中实现RPC业务线程池的示例代码如下：

public class RpcRequestHandler extends SimpleChannelInboundHandler<MiniRpcProtocol<MiniRpcRequest>> {
    
    private final EventExecutorGroup businessExecutorGroup;

    public RpcRequestHandler(EventExecutorGroup businessExecutorGroup) {
        this.businessExecutorGroup = businessExecutorGroup;
    }

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, MiniRpcProtocol<MiniRpcRequest> protocol) {
        // 将耗时的业务处理提交到业务线程池
        businessExecutorGroup.submit(() -> {
            // 处理 RPC 请求
            MiniRpcRequest request = protocol.getRequest();
            // 执行业务逻辑...
        });
    }
    
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        // 处理异常
        ctx.close();
    }
}

在这个示例中，

RpcRequestHandler

通过构造函数接收一个 

EventExecutorGroup

（业务线程池），并在 

channelRead0

方法中使用它来异步处理 RPC 请求。这样，即使业务逻辑耗时较长，也不会阻塞 I/O 线程，从而保证了网络通信的高效性。

共享的ChannelHandler

在 Netty 中，

@Sharable

注解用于标记 

ChannelHandler

，表示该处理器是可共享的，即它可以被多个 

ChannelPipeline

实例安全地共享和重用。这种做法对于减少内存消耗和提高资源利用率非常有帮助，特别是当系统需要处理大量连接时。

使用 @Sharable 注解的好处：

  1. 内存优化：避免为每个新连接创建处理器实例，减少内存消耗。
  2. 性能提升：减少对象创建的开销，可能提升系统的整体性能。
  3. 资源复用：允许将处理器作为资源在多个连接之间复用。

使用 @Sharable 注解的条件：

  1. 无状态：被标记为 @Sharable 的 ChannelHandler 必须是无状态的，即它们的 channelRead0、write 等方法的实现不依赖于任何实例变量。
  2. 线程安全：处理器内部的实现必须是线程安全的，因为同一个处理器实例可能会被多个线程并发访问。
  3. 单例：通常，使用 @Sharable 注解的 ChannelHandler 会设计为单例模式，即全局只有一个实例。

示例代码：

@ChannelHandler.Sharable
public class SharedHandler extends ChannelInboundHandlerAdapter {

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) {
        // 处理接收到的消息
    }

    // 可以添加其他事件处理方法
}

// 在初始化时使用 SharedHandler
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
 .channel(NioServerSocketChannel.class)
 .localAddress(new InetSocketAddress(port))
 .childHandler(new ChannelInitializer<SocketChannel>() {
     @Override
     public void initChannel(SocketChannel ch) {
         ch.pipeline()
             .addLast(new SharedHandler())  // SharedHandler 实例被共享
             .addLast(new HandlerB());
     }
 });

注意事项：

  • 在设计 @Sharable 处理器时，要确保它不会持有任何连接特定的状态信息。
  • 如果处理器需要持有状态，那么就不能使用 @Sharable 注解，而应该为每个连接创建新的处理器实例。
  • 在 Netty 4.x 版本中，@Sharable 注解已经标记为过时（deprecated），推荐使用 @ChannelHandler.Sharable 注解代替。

通过合理使用 

@Sharable

注解，可以有效地优化内存使用和提升系统性能，特别是在高并发的网络应用中。

高低水位线优化

在 Netty 中，设置高低水位线（

WRITE_BUFFER_HIGH_WATER_MARK

和 

WRITE_BUFFER_LOW_WATER_MARK

）是一种流控机制，用于防止因为发送太快而导致的内存溢出或网络拥塞。以下是关于高低水位线的详细说明和设置方法：

高水位线（WRITE_BUFFER_HIGH_WATER_MARK）

  • 作用：当 Channel 的写缓存区大小超过这个阈值时，Channel 会被设置为不可写状态。
  • 默认值：Netty 默认的高水位线是 64KB。
  • 设置方法：通过 ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK 设置。

低水位线（WRITE_BUFFER_LOW_WATER_MARK）

  • 作用：当写缓存区大小低于这个阈值时，Channel 会恢复为可写状态。
  • 默认值：Netty 默认的低水位线是 32KB，这个值通常小于高水位线。
  • 设置方法：通过 ChannelOption.WRITE_BUFFER_LOW_WATER_MARK 设置。

设置高低水位线的建议

  • 测试：在调整高低水位线之前，建议有足够的测试数据作为参考，以确保设置的值适合你的应用场景。
  • 不要随意更改：如果没有充分的测试，不建议随意更改高低水位线的默认值。

Netty 中的高低水位线设置示例

对于服务器端（Server）和客户端（Client）的设置：

// 服务器端设置
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.childOption(ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK, 32 * 1024);
bootstrap.childOption(ChannelOption.WRITE_BUFFER_LOW_WATER_MARK, 8 * 1024);

// 客户端设置
Bootstrap bootstrap = new Bootstrap();
bootstrap.option(ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK, 32 * 1024);
bootstrap.option(ChannelOption.WRITE_BUFFER_LOW_WATER_MARK, 8 * 1024);

检查 Channel 是否可写

在发送数据之前，应该检查 

Channel

是否可写，这可以通过调用 

isWritable()

方法来实现：

if (ctx.channel().isActive() && ctx.channel().isWritable()) {
    ctx.writeAndFlush(message);
} else {
    // 如果 Channel 不可写，处理消息，例如暂存或丢弃
}

这种检查可以防止因为接收方处理速度慢而导致的内存溢出问题。

GC优化

在 JVM 参数调优中，针对不同的网络应用程序场景，合理设置 GC（垃圾回收）参数是非常重要的。

堆内存（Heap Memory）

  • -Xms 和 -Xmx 参数： - -Xms：设置 JVM 启动时的初始堆内存大小。- -Xmx：设置 JVM 堆内存的最大值。
  • 生产环境建议： - 对于生产环境，建议将 -Xms 和 -Xmx 设置为相同的值，以避免动态调整堆大小带来的额外 GC 开销。- 合理调整 -Xmx 可以减少 Full GC 的频率，从而降低 GC 开销并提升系统吞吐量。

堆外内存（Off-Heap Memory）

  • DirectByteBuffer： - 使用 DirectByteBuffer 时，容易造成 OutOfMemoryError，因为它占用的是堆外内存。- DirectByteBuffer 的回收通常依赖于 Old GC 或 Full GC。
  • -XX:MaxDirectMemorySize 参数： - 通过设置 -XX:MaxDirectMemorySize 参数来限制堆外内存的最大值。- 超过此阈值时，会触发 Full GC 进行清理，如果 Full GC 后仍无法满足需求，则抛出 OOM 异常。

年轻代（Young Generation）

  • -Xmn 参数： - 调整新生代（Young Generation）的大小。
  • -XX:SurvivorRatio 参数： - 设置 Survivor 区和 Eden 区的比例。
  • 调优建议： - 如果程序中存在大量短命对象，应适当增加新生代的大小以减少 YGC（Young Generation GC）的频率。- 在延迟敏感的应用场景（如长连接服务）中，优化新生代空间大小和比例可以显著提升性能。

其他重要参数

  • GC 策略选择： - 根据应用特点选择合适的 GC 策略，如 CMS、G1、ZGC 等。
  • 监控和日志： - 开启 GC 日志记录，监控 GC 行为和性能指标，以便进一步调优。
  • 内存泄漏排查： - 使用工具（如 jmap、jstack）定期检测内存泄漏。

示例 JVM 参数设置

java -Xms1024m -Xmx1024m -XX:MaxDirectMemorySize=256m -Xmn300m -XX:SurvivorRatio=8 -XX:+UseG1GC ...

在这个示例中：

  • 初始堆和最大堆大小被设置为 1024MB。
  • 堆外内存的最大值被限制为 256MB。
  • 新生代大小设置为 300MB。
  • Survivor 区和 Eden 区的比例设置为 8:1。
  • 使用 G1 垃圾回收器。

结论

GC 参数优化需要根据应用程序的具体需求和运行时表现来进行。通过监控、测试和调整，可以找到最适合当前应用场景的参数配置，从而提升性能并降低资源消耗。

在 Netty 中，内存池和对象池是两种用于提高性能和减少资源分配开销的重要机制。

内存池和对象池优化

内存池（ByteBuf 池）

Netty 提供了 

PooledByteBufAllocator

作为内存池的实现，它可以用于分配和管理 

ByteBuf

。有两种类型的 

ByteBuf

：

  • HeapByteBuf：基于 JVM 堆内存的 ByteBuf 实现。
  • DirectByteBuf：基于堆外内存的 ByteBuf 实现，通常与 NIO 直接缓冲区配合使用。

使用 

PooledDirectByteBuf

（池化的直接缓冲区）可以减少堆外内存的分配和回收开销。因为直接缓冲区的分配和回收比堆内存慢，所以通过内存池预先分配一块大的内存区域，并从中按需分配小块内存，可以提高性能。

启用内存池的示例代码：
ServerBootstrap bootstrap = new ServerBootstrap();
bootstrap.option(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);
bootstrap.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);

对象池（Recycler 对象池）

Netty 的 

Recycler

对象池用于对象的复用，减少对象创建和垃圾回收的开销。通过 

Recycler

，可以重用实现了 

Recyclable

接口的对象，从而优化性能并减少 GC。

Product

对象池示例：

下面是一个简单的示例，展示如何使用 

Recycler

来创建一个商品对象池。

首先，我们定义一个 

Product

类，它将被池化：

public class Product implements Recyclable {
    private String name;
    private Recycler.Handle<Product> handle;

    public Product(Recycler.Handle<Product> handle) {
        this.handle = handle;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public void recycle() {
        // 重置对象状态，以便重用
        name = null;
        handle.recycle(this);
    }
}

接下来，我们创建一个 

ProductCache

类，它使用 

Recycler

来管理 

Product

对象的创建和回收：

public class ProductCache {
    private static final Recycler<Product> productRecycler = new Recycler<Product>() {
        @Override
        protected Product newObject(Recycler.Handle<Product> handle) {
            return new Product(handle);
        }
    };

    public static Product newProduct() {
        // 从对象池中获取 Product 对象
        return productRecycler.get();
    }
}

最后，我们展示如何在应用程序中使用这个对象池：

public class ProductPoolExample {
    public static void main(String[] args) {
        // 从对象池获取 Product 对象
        Product product1 = ProductCache.newProduct();
        product1.setName("商品A");

        // 使用完毕后，回收对象
        product1.recycle();

        // 再次从对象池获取对象
        Product product2 = ProductCache.newProduct();
        System.out.println(product2.getName()); // 可能会输出 null，因为对象已经被回收并重置

        // 再次使用对象
        product2.setName("商品B");
        // 处理商品B的逻辑...

        // 再次回收对象
        product2.recycle();
    }
}

在这个示例中，我们创建了一个 

Product

类，它实现了 

Recyclable

接口，这意味着它可以被回收和重用。

ProductCache

类包含一个静态的 

Recycler

对象，用于管理 

Product

实例的创建和回收。我们通过 

ProductCache.newProduct()

方法从池中获取新的对象，并在不再需要时通过调用 

recycle()

方法将对象回收到池中。

使用对象池可以帮助我们减少对象创建的开销，特别是在高性能和高并发的场景中，这种方法可以显著提高应用程序的效率。

总结

内存池和对象池都是 Netty 中用于优化资源管理的技术。内存池通过预先分配内存块并按需分配，减少了直接缓冲区分配的开销。对象池通过重用对象，减少了对象创建和销毁的开销，同时对 JVM 的垃圾回收也是友好的。这两种技术都有助于构建高性能且稳定的网络应用程序。

标签： 性能优化 网络 java
本文转载自: https://blog.csdn.net/m0_63833709/article/details/139329338
版权归原作者 m0_63833709 所有， 如有侵权，请联系我们删除。
登录后发布评论

“深入netty22-netty性能优化和最佳实践”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？

文章导航