我想要一个非常有效的TCP客户端来发送谷歌协议缓冲消息.我一直在使用Netty库来开发服务器/客户端.
在测试中,服务器似乎能够每秒处理多达500k的事务,而不会遇到很多问题,但客户端往往会以每秒180k的事务数达到峰值.
我的客户端基于Netty文档中提供的示例,但区别在于我只想发送消息而忘记,我不想要响应(大多数示例都得到了).无论如何都要优化我的客户端,以便我可以实现更高的TPS？
我的客户应该维护多个渠道,还是应该能够通过单一渠道实现更高的吞吐量？
我正在写一个Netty应用程序.该应用程序运行在64位八核Linux机箱上
Netty应用程序是一个简单的路由器,它接受请求(传入管道)从请求中读取一些元数据并将数据转发到远程服务(传出管道).
此远程服务将返回对传出管道的一个或多个响应.Netty应用程序将响应路由回原始客户端(传入管道)
将有成千上万的客户.将有数以千计的远程服务.
我正在进行一些小规模的测试(10个客户端,10个远程服务),我没有看到我预计的99毫秒的低于10毫秒的性能.我正在测量客户端和服务器端的延迟.
我正在使用类似于SPDY的完全异步协议.当我们处理FrameDecoder中的第一个字节时,我捕获时间(我只使用System.nanoTime()).我在调用channel.write()之前就停止了计时器.我正在测量从输入管道到输出管道的亚毫秒时间(99.9百分位数),反之亦然.
我还测量了从FrameDecoder中的第一个字节到在(上面)message.write()上调用ChannelFutureListener回调的时间.时间是几十毫秒(99.9百分位数),但我难以说服自己这是有用的数据.
我最初的想法是我们有一些缓慢的客户.我看了channel.isWritable()并在返回false时记录.在正常条件下,此方法不返回false
一些事实:
是否有一种调试技术,我可以遵循以确定为什么我的Netty应用程序没有像我认为的那样快速运行？
感觉就像channel.write()将消息添加到队列中,而我们(使用Netty的应用程序开发人员)对此队列没有透明性.我不知道队列是Netty队列,OS队列,网卡队列还是什么.无论如何,我正在审查现有应用程序的示例,我没有看到我正在遵循的任何反模式
感谢您的帮助/见解
在阅读Netty教程时,我发现了如何集成Netty和Google Protocol Buffers的简单描述.我已经开始研究它的例子(因为文档中没有更多的信息)并编写了一个简单的应用程序,如示例本地时间应用程序.但是这个例子是在PipeFactory类中使用静态初始化,例如:
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.handler.codec.protobuf.ProtobufDecoder;
import org.jboss.netty.handler.codec.protobuf.ProtobufEncoder;
import org.jboss.netty.handler.codec.protobuf.ProtobufVarint32FrameDecoder;
import org.jboss.netty.handler.codec.protobuf.ProtobufVarint32LengthFieldPrepender;
import static org.jboss.netty.channel.Channels.pipeline;
/**
* @author sergiizagriichuk
*/
class ProtoCommunicationClientPipeFactory implements ChannelPipelineFactory {
public ChannelPipeline getPipeline() throws Exception {
ChannelPipeline p = pipeline();
p.addLast("frameDecoder", new ProtobufVarint32FrameDecoder());
p.addLast("protobufDecoder", new ProtobufDecoder(Communication.DataMessage.getDefaultInstance()));
p.addLast("frameEncoder", new ProtobufVarint32LengthFieldPrepender());
p.addLast("protobufEncoder", new ProtobufEncoder());
p.addLast("handler", new ProtoCommunicationClientHandler());
return p;
}
}
(请看一下p.addLast("protobufDecoder", new ProtobufDecoder(Communication.DataMessage.getDefaultInstance()));),只有一个工厂可以创建(据我所知)ClientBootstrap,我的意思是bootstrap.setPipelineFactory()方法.所以,在这种情况下,我可以使用ONE 消息发送给服务器,并ONE消息从服务器接收,这是对我不好,我想不只是我:(我如何使用不同的信息,并从其只是一个连接？也许我可以创造一些protobufDecoder像这样的东西
p.addLast("protobufDecoder", new ProtobufDecoder(Communication.DataMessage.getDefaultInstance()));
p.addLast("protobufDecoder", …我正在考虑将web套接字Netty用于客户端连接到服务器以获取一些信息的应用程序.然后,它们由服务器注册,并且对特定客户端的信息的任何改变将触发包含更新信息的客户端的通知.在这种情况下,通信首先由客户端启动,后者由服务器启动.因此,网络套接字似乎适应了这种情况.
但是,在它启动后,我希望我的客户端能够随时被服务器通知.可能是几周之后的一天.那么,我的问题是使用网络套接字可以实现非常长寿的连接吗？
谢谢
有什么区别吗？是否ctx.close只是一个较短的版本ctx.channel.close？
由于Netty是一个非阻塞服务器,将操作更改为使用会产生什么影响.async？
def index = Action { ... }
与
def index = Action.async { ... }
我明白,.async你会得到一个Future[SimpleResult].但是既然Netty没有阻止,那么Play会不会做类似的事情呢？
这会对吞吐量/可扩展性产生什么影响？这是一个难以回答的问题,它取决于其他因素吗？
我问的原因是,我有自己的自定义Action,我想重置每个页面请求的cookie超时,所以我这样做是一个async调用:
object MyAction extends ActionBuilder[abc123] {
def invokeBlock[A](request: Request[A], block: (abc123[A]) => Future[SimpleResult]) = {
...
val result: Future[SimpleResult] = block(new abc123(..., result))
result.map(_.withCookies(...))
}
}
从上面的代码片段拿走是我使用的Future[SimpleResult],这类似于调用,Action.async但这是在我的Action内部吗？
我想了解这会对我的应用程序设计产生什么影响.似乎只是为了能够在每个请求的基础上设置我的cookie,我已经从阻塞变为非阻塞.但是我很困惑,因为Netty没有阻塞,也许我真的没有改变现实,因为它已经是异步的？
或者我只是创建了另一个嵌入另一个异步调用？
希望有人能够通过一些细节来阐明这一点,以及这将在性能/吞吐量方面产生的影响.
目前我只是尝试下载和构建以使Netty源代码工作.但是当我尝试mvn eclipse:eclipse在源文件夹中运行该命令时.我说错了
[ERROR] Failed to execute goal org.apache.maven.plugins:maven-checkstyle-plugin:2.10:check (check-style) on project netty-common: Failed during checkstyle execu
tion: There are 304 checkstyle errors. -> [Help 1]
org.apache.maven.lifecycle.LifecycleExecutionException: Failed to execute goal org.apache.maven.plugins:maven-checkstyle-plugin:2.10:check (check-style) on proj
ect netty-common: Failed during checkstyle execution
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:212)
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:153)
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:145)
at org.apache.maven.lifecycle.internal.MojoExecutor.executeForkedExecutions(MojoExecutor.java:352)
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:197)
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:153)
at org.apache.maven.lifecycle.internal.MojoExecutor.execute(MojoExecutor.java:145)
at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:116)
at org.apache.maven.lifecycle.internal.LifecycleModuleBuilder.buildProject(LifecycleModuleBuilder.java:80)
at org.apache.maven.lifecycle.internal.builder.singlethreaded.SingleThreadedBuilder.build(SingleThreadedBuilder.java:51)
at org.apache.maven.lifecycle.internal.LifecycleStarter.execute(LifecycleStarter.java:128)
at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:307)
at org.apache.maven.DefaultMaven.doExecute(DefaultMaven.java:193)
at org.apache.maven.DefaultMaven.execute(DefaultMaven.java:106)
at org.apache.maven.cli.MavenCli.execute(MavenCli.java:863)
at org.apache.maven.cli.MavenCli.doMain(MavenCli.java:288)
at org.apache.maven.cli.MavenCli.main(MavenCli.java:199)
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
at …我看过Spring Tips:使用Spring Framework 5.0的功能反应端点,并阅读了一些关于spring reactor的内容,但我无法理解它.
鉴于我有netty和spring reactor有效,让端点返回Flux/ Mono实例(jacksonified)而不是直接dto对象(jacksonified)有什么好处？我最初假设在http请求/响应上下文中,反应流将更像是websockets,其中服务器通过开放通道将数据推送到接收器,但似乎并非如此.
另外netty在反应式编程中实际上比tomcat做得更好？
如果这些问题看起来很愚蠢,我很抱歉,但我不太明白这个新框架方向的目的.它为什么会出现,它是如何工作的以及它解决了哪些问题？
spring reactive-programming netty project-reactor spring-webflux
我正在使用带有logback的slf4j日志记录,并在我编写的应用程序的开头
InternalLoggerFactory.setDefaultFactory(new Slf4JLoggerFactory());
然后我在管道中添加了一个新LoggingHandler(InternalLogLevel.DEBUG)实例.不幸的是,这仍然没有记录任何东西,我正在调试,调试级别是问题,只是跳过日志记录本身.
我该如何设置才能使用它LoggingHandler？