记一次Netty模拟压测应用开发

背景

最近需要开发一个上游端模拟数据推送,测试高流量下下游的业务功能处理速度,大致架构如下

准备工作

构造消息体,由于是模拟大量数据推送并没有业务逻辑,所以我们使用池化的directBuffer增加推送消息以及减少创建和消费buffer的开销

cpp 复制代码
   public static ByteBuf buildMessage(int Id) {
        ByteBuf buffer = allocator.directBuffer(32).order(ByteOrder.LITTLE_ENDIAN);
        // 设置小端模式读取整数
        buffer.writeShort((short) 32);
        buffer.writeShort((short) 50);
        buffer.writeInt(Id); // uint32
        buffer.writeInt(ThreadLocalRandom.current().nextInt(2, 500)); // uint32
        buffer.writeInt(ThreadLocalRandom.current().nextInt(2, 500)); // int32
        buffer.writeInt(ThreadLocalRandom.current().nextInt(2, 500)); // uint32
        buffer.writeShort((short) 0); // int16
        buffer.writeBytes(new byte[2]);
        buffer.writeLong(System.nanoTime()); // uint64
        return buffer;
    }

构造启动程序,上游无需处理业务逻辑只用造数据,下游需要处理业务逻辑所以这里的发送和消费的速率是不一致的。需要加上高低水位同时判断channel是否可写来调节发送速率,避免发送端内存溢出 启动配置

cpp 复制代码
bootstrap.childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, new WriteBufferWaterMark(64 * 1024 * 1024, 102 * 1024 * 1024));
bootstrap.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT);

发送代码

cpp 复制代码
if (channel.isActive() && channel.isWritable()) {
    // send
}

在何处发送消息

最开始我在启动类中写了一个统一产生消息并发送给所有的已连接的客户端的方法 代码如下

cpp 复制代码
public static void scanLoop(Server nettyServer) {
        int nThreads = Integer.parseInt(System.getProperty("test.thread.nums"));
        ExecutorService executorService = Executors.newCachedThreadPool();
        for (int i = 0; i < nThreads; i++) {
            executorService.execute(() -> {
                log.info("启动netty");
                while (true) {
                    List<ByteBuf> bufList = Lists.newArrayList(
                            generateMessage(700),
                            generateMessage(9988)
                    );
                    for (ByteBuf byteBuf : bufList) {
                        nettyServer.sendAllClientMessage(byteBuf);
                    }
                }
            });
        }
    }

但是产生了一个问题,服务启动不到一分钟就内存溢出了,哪怕线程数是1也会溢出。最主要的问题就是发送端生产消息的速率没有做控制。造成溢出的点有两个

  1. PoolChunk对象内存溢出
  2. NioEventLoop的taskQueue队列溢出 要解决这个问题有两个方法,第一个是在发送端增加限流器来控制发送端生产消息的速度。第二个就是在每个客户端内部去构造一个发送器通过判断通道是否可写来进行发送

发送端限流器

这里使用guava的令牌桶来限制消息的发送频率,同时也控制了消息的生产速度。但这么做还是有可能产生内存溢出,毕竟没有从接收端的高水位状态来判断是否产生消息。而且为了保证压测速率对于限流的值进行合理值设定也是一个难点。

cpp 复制代码
public static void scanLoop(Server nettyServer) {
        int nThreads = Integer.parseInt(System.getProperty("test.thread.nums"));
        ExecutorService executorService = Executors.newCachedThreadPool();
        RateLimiter limiter = RateLimiter.create(10000);
        for (int i = 0; i < nThreads; i++) {
            executorService.execute(() -> {
                log.info("启动netty");
                while (true) {
                    List<ByteBuf> bufList = Lists.newArrayList(
                            generateMessage(700),
                            generateMessage(9988)
                    );
                    for (ByteBuf byteBuf : bufList) {
                        limiter.acquire();
                        quotesNettyServer.sendAllClientMessage(byteBuf);
                    }
                }
            });
        }
    }

客户端内部发送

为了根据接收端的高水位状态来调整发送速率,我们将统一发送的逻辑变更到客户端内部的handler中来实现 在客户端连接时,在其内部client处启动一个线程来发送消息,同时判断通道是否可写来产生消息。这样能够保证发送端应生产消息的效率而导致内存泄漏的问题可以解决。

cpp 复制代码
public class ClientConnectHandler extends ChannelInboundHandlerAdapter {
	 @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
		for (int i = 0; i < nThreads; i++) {
            executorService.execute(() -> {
                while (true) {
                    if (channel.isActive() && channel.isWritable()) {
                        List<ByteBuf> bufList = Lists.newArrayList(
                                StockBufferUtils.generateMessage(700),
                                StockBufferUtils.generateMessage(9988),
                                StockBufferUtils.generateMessage(9626),
                                StockBufferUtils.generateMessage(3690)
                        );
                        bufList.forEach(e -> ctx.writeAndFlush(e));
                    }
                }
            });
        }
	}
}

测试

最后进行发送测试,每分钟的消息发送数量能够达到100万左右,差不多已经是接收端极限了。

cpp 复制代码
channel:[[id: 0xdca25775, L:/127.0.0.1:9000 - R:/127.0.0.1:50817]]
 消息数量:[1096236]
during write size --- 57.18 MB
during read size --- 0.00 MB
during write throughput --- 999.24 KB/s
during read throughput  --- 0.00 KB/s
total read size: 0.00 MB
total write size: 1503.62 MB
current buffer size:0
相关推荐
尘浮生1 小时前
Java项目实战II基于Spring Boot的火锅店管理系统设计与实现(开发文档+数据库+源码)
java·开发语言·数据库·spring boot·后端·微信小程序·旅游
咸芝麻鱼2 小时前
django模板出现:‘WSGIRequest‘ object has no attribute ‘Get‘错误
后端·python·django
京东零售技术2 小时前
通过Forcebot压测实践简述“并发模式”与“RPS模式”两种模式的区别
后端
knoci2 小时前
【Go】-基于Gin框架的博客项目
后端·学习·golang·gin
Xiaoyu Wang4 小时前
Go语言八股(Ⅲ)
开发语言·后端·golang
Ruoyo1764 小时前
【Flask框架】10、Flask项目拆分规范
后端·python·flask
Loong_DQX4 小时前
[flask] flask-mail邮件发送
后端·python·flask
hummhumm4 小时前
Oracle 第13章:事务处理
开发语言·数据库·后端·python·sql·oracle·database
除了菜一无所有!6 小时前
基于SpringBoot技术的教务管理
java·spring boot·后端
DEARM LINER8 小时前
mysql 巧妙的索引
数据库·spring boot·后端·mysql