似乎Netty只能使用单个TCP连接处理读取或写入操作，但不能同时处理两者。我有一个客户端连接到使用Netty编写的echo服务器应用程序，并发送大约200k消息。
echo服务器只接受客户端连接并发送回客户端发送的任何消息。
问题是我不能让Netty在全双工模式下使用TCP连接。我想同时处理服务器端的读写操作。在我的例子中，Netty从客户端读取所有消息，然后将它们发回，这导致了高延迟。
客户端应用程序每个连接触发两个线程。一个用于任何写操作，另一个用于读操作。是的，客户端是用简单的旧Java IO风格编写的。
也许这个问题与我在服务器端设置的TCP选项有某种关系：
.childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
.childOption(ChannelOption.WRITE_BUFFER_HIGH_WATER_MARK, bufferWatermarkHigh)
.childOption(ChannelOption.WRITE_BUFFER_LOW_WATER_MARK, bufferWatermarkLow)
.childOption(ChannelOption.SO_RCVBUF, bufferInSize)
.childOption(ChannelOption.SO_SNDBUF, bufferOutSize)
.childOption(ChannelOption.SO_REUSEADDR, true)
.childOption(ChannelOption.SO_KEEPALIVE, true)
.childOption(ChannelOption.TCP_NODELAY, true);
答案 0 :(得分：3)
在您使用github repo提供的示例中，有多个错误的内容：
您直接使用channelActive方法
在netty中，有一个策略，每个处理程序只有一个传入方法同时执行，这是为了使开发更容易，并确保类的方法以正确的顺序执行，它也这样做确保方法的副作用在其他类中可见。
channelReadComplete channelReadComplete，channelRead可能会在调用之前多次调用。
构建消息或计算消息大小是检测内部字节数的方法。对于客户端的2次写入，可以在没有此成帧器的服务器上读取1次，作为测试，我使用了new io.netty.handler.codec.FixedLengthFrameDecoder(120)，因此我可以使用i++计算到达服务器和客户端的消息量。
**使用重磅打印进行轻量化操作。
根据我的探查器，大部分时间都在调用LOG.info()，这通常是记录器的情况，因为它们在幕后做很多事情，比如输出流的同步。通过使记录器仅记录每1000ste消息，我得到了巨大的速度增加（并且因为我在双核上运行，所以计算机非常慢......）
重发代码
发送代码每次都会重新创建ByteBuf。通过重用ByteBuf，您可以进一步提高发送速度，您可以通过创建ByteBuf 1次，然后每次通过时调用.retain()来完成此操作。
这可以通过以下方式轻松完成：
ByteBuf buf = createMessage(MESSAGE_SIZE);
for (int i = 0; i < NUMBER_OF_MESSAGES; ++i) {
ctx.writeAndFlush(buf.retain());
}
减少冲款次数
通过减少刷新量，您可以获得更高的原生性能。每次调用flush（）都是对网络堆栈的调用，以发送待处理的消息。如果我们将该规则应用于上面的代码，它将提供以下代码：
ByteBuf buf = createMessage(MESSAGE_SIZE);
for (int i = 0; i < NUMBER_OF_MESSAGES; ++i) {
ctx.write(buf.retain());
}
ctx.flush();
有时候，你只是想看看结果并自己尝试一下：
App.java（未更改）
public class App {
public static void main( String[] args ) throws InterruptedException {
final int PORT = 8080;
runInSeparateThread(() -> new Server(PORT));
runInSeparateThread(() -> new Client(PORT));
}
private static void runInSeparateThread(Runnable runnable) {
new Thread(runnable).start();
}
}
<强> Client.java
public class Client {
public Client(int port) {
EventLoopGroup group = new NioEventLoopGroup();
try {
ChannelFuture channelFuture = createBootstrap(group).connect("192.168.171.102", port).sync();
channelFuture.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
group.shutdownGracefully();
}
}
private Bootstrap createBootstrap(EventLoopGroup group) {
return new Bootstrap().group(group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(
new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new io.netty.handler.codec.FixedLengthFrameDecoder(200));
ch.pipeline().addLast(new ClientHandler());
}
}
);
}
}
<强> ClientHandler.java
public class ClientHandler extends ChannelInboundHandlerAdapter {
private final Logger LOG = LoggerFactory.getLogger(ClientHandler.class.getSimpleName());
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
final int MESSAGE_SIZE = 200;
final int NUMBER_OF_MESSAGES = 200000;
new Thread(()->{
ByteBuf buf = createMessage(MESSAGE_SIZE);
for (int i = 0; i < NUMBER_OF_MESSAGES; ++i) {
ctx.writeAndFlush(buf.retain());
}}).start();
}
int i;
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if(i++%10000==0)
LOG.info("Got a message back from the server "+(i));
((io.netty.util.ReferenceCounted)msg).release();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
private ByteBuf createMessage(int size) {
ByteBuf message = Unpooled.buffer(size);
for (int i = 0; i < size; ++i) {
message.writeByte((byte) i);
}
return message;
}
}
<强> Server.java
public class Server {
public Server(int port) {
EventLoopGroup bossGroup = new NioEventLoopGroup(1);
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ChannelFuture channelFuture = createServerBootstrap(bossGroup, workerGroup).bind(port).sync();
channelFuture.channel().closeFuture().sync();
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
private ServerBootstrap createServerBootstrap(EventLoopGroup bossGroup,
EventLoopGroup workerGroup) {
return new ServerBootstrap().group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new io.netty.handler.codec.FixedLengthFrameDecoder(200));
ch.pipeline().addLast(new ServerHandler());
}
});
}
}
<强> ServerHandler.java
public class ServerHandler extends ChannelInboundHandlerAdapter {
private final Logger LOG = LoggerFactory.getLogger(ServerHandler.class.getSimpleName());
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ctx.writeAndFlush(msg).addListener(f->{if(f.cause()!=null)LOG.info(f.cause().toString());});
if(i++%10000==0)
LOG.info("Send the message back to the client "+(i));
;
}
int i;
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
// LOG.info("Send the message back to the client "+(i++));
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
我决定测试如果我更改记录的incmoing消息的频率会发生什么，这些是测试结果：
What to print: max message latency time taken*
(always) > 20000 >10 min
i++ % 10 == 0 > 20000 >10 min
i++ % 100 == 0 16000 4 min
i++ % 1000 == 0 0-3000 51 sec
i++ % 10000 == 0 <10000 22 sec
*时间应该用一粒盐，没有真正的基准测试，只有1个快速的程序运行
这表明通过减少对log（精度）的调用量，我们可以获得更好的传输速率（速度）。