Question

我正在编写一个基于Netty的本地HTTP服务器。当我进行压力测试时，我受限于400请求/秒。

为了优化我的服务器，我编写了一个基于Netty的简单服务器，它只向客户端发送“Hello World”，然后我用Gatling 2启动了压力测试，并且通过这台服务器，我得到了相同的结果（限于400 req / s）。

我使用Yourkit进行性能分析，没有额外的GC活动，我的开放/关闭套接字限制为480个套接字/秒。

我使用MacBook Pro，有4核，16 GB RAM，我使用的是Netty 4.1。

我很惊讶地限制在400 req / s，因为其他基准测试的结果显示> 20 000 req / s或更多。我知道有硬件限制，但400 req / s，在4核+ 16 GB Ram上发送“hello World”非常低。

提前感谢您的帮助，我不知道从哪里开始优化我的Netty代码。

是否有任何优化Netty的具体指导原则？

这是我的hello world服务器的源代码，后面跟着我的连接处理程序：

public class TestServer {

    private static final Logger logger = LogManager.getLogger("TestServer");

    int nbSockets = 0 ;

    EventLoopGroup pool = new NioEventLoopGroup() ;

    private void init(int port) {

        EventLoopGroup bossGroup = new NioEventLoopGroup(100) ;


        try {
            long t1 = System.currentTimeMillis() ;
            ServerBootstrap b = new ServerBootstrap().group(bossGroup);

            b.channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast("decoder", new HttpRequestDecoder(8192, 8192 * 2,
                                    8192 * 2));
                            ch.pipeline().addLast("encoder", new HttpResponseEncoder());

                            ch.pipeline().addLast(new TestServerHandler(TestServer.this));
                        }

                        @Override
                        public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
                            System.err.println("Error");
                            super.exceptionCaught(ctx,cause);
                        }


                    })
                    .option(ChannelOption.SO_BACKLOG, 100000)
                    .option(ChannelOption.SO_KEEPALIVE,false)
                    .option(ChannelOption.TCP_NODELAY,false)
                    .option(ChannelOption.SO_REUSEADDR,true)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS,10000)
                    .childOption(ChannelOption.SO_KEEPALIVE, true);

            ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);;

            scheduler.scheduleAtFixedRate(new Runnable() {
                @Override
                public void run()  {
                    System.err.println(nbSockets);
                    nbSockets = 0 ;
                }
            },1, 1,TimeUnit.SECONDS) ;


            // Bind and start to accept incoming connections.
            ChannelFuture f = b.bind(port).sync();

            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            System.err.println("Coucou");
        }
    }

    public static void main(String[] args) {
        TestServer testServer = new TestServer() ;
        testServer.init(8888);
    }
}

这是我的处理程序的源代码：

public class TestServerHandler extends ChannelInboundHandlerAdapter {
    private final TestServer testServer;

    public TestServerHandler(TestServer testServer) {
        this.testServer = testServer ;
    }


    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        try {
            process(ctx, msg);
        } catch (Throwable e) {
            e.printStackTrace();
        }


    }

    public void process(ChannelHandlerContext ctx, Object msg) throws Exception {
        ctx.channel().writeAndFlush(buildHttpResponse()).addListener(new GenericFutureListener<Future<? super Void>>() {
            @Override
            public void operationComplete(Future<? super Void> future) throws Exception {
                ctx.channel().close() ;
                testServer.nbSockets ++ ;
            }
        }) ;
    }

    public DefaultFullHttpResponse buildHttpResponse() {

        String body = "hello world" ;
        byte[] bytes = body.getBytes(Charset.forName("UTF-8"));
        ByteBuf byteContent = Unpooled.copiedBuffer(bytes);
        HttpResponseStatus httpResponseStatus =HttpResponseStatus.OK;

        DefaultFullHttpResponse httpResponse = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1,
                httpResponseStatus, byteContent);


        return httpResponse;
    }

}

Answer 1

你已经禁用了keep-alive并且正在关闭每个请求的连接，所以我怀疑你花了大部分时间来打开和关闭HTTP连接。

因为其他基准测试的结果显示> 20 000 req / s或更多

您指的是哪些其他基准？很有可能它们都是池化连接，并且使用HTTP流水线技术，因此与你的用法截然不同。

回到原来的问题（如何优化Netty），你可以做两件事：

微优化分配：使用池化的ByteBuffers，或者甚至更好地计算它们一次
切换到native epoll transport（仅限Linux）

但是所有这些改进与连接处理相比可能不会太多。

Netty应用程序优化

1 个答案: