6、Netty 高性能架构设计
提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档
文章目录
- Netty概述
- 原生NIO存在的问题
- Netty官网说明
- Netty的优点
- Netty版本说明
- 线程模型基本介绍
- 传统阻塞 I/O 服务模型
- 工作原理图
- 模型特点
- 问题分析
- Reactor 模式
- 单 Reactor 单线程
- 单Reactor多线程
- 主从 Reactor 多线程
- 3 种模式用生活案例来理解
- Reactor 模式具有如下的优点:
- Netty模型
- 工作原理示意图1-简单版
- 工作原理示意图2-进阶版
- 工作原理示意图-详细版
- Netty快速入门实例-TCP服务
- 任务队列中的 Task 有 3 种典型使用场景
- taskQueue自定义任务
- 提出问题
- 解决方案1:用户自定义的普通任务
- scheduleTaskQueue用户自定义定时任务
- 方案再说明
- 异步模型
- 基本介绍
- Future 说明
- 工作原理示意图
- 示例
- Future-Listener 机制
- 快速入门实例-HTTP服务
Netty概述
原生NIO存在的问题
- NIO 的类库和 API 繁杂,使用麻烦:需要熟练掌握 Selector、ServerSocketChannel、 SocketChannel、ByteBuffer 等。
- 需要具备其他的额外技能:要熟悉 Java 多线程编程,因为 NIO 编程涉及到 Reactor 模式,你必须对多线程和网络编程非常熟悉,才能编写出高质量的 NIO 程序。
- 开发工作量和难度都非常大:例如客户端面临断连重连、网络闪断、半包读写、失 败缓存、网络拥塞和异常流的处理等等。
- JDK NIO 的 Bug:例如臭名昭著的 Epoll Bug,它会导致 Selector 空轮询,最终导 致 CPU 100%。直到 JDK 1.7 版本该问题仍旧存在,没有被根本解决。
Netty官网说明
官网:https://netty.io/
Netty is an asynchronous event-driven network application framework for rapid development of maintainable high performance protocol servers & clients
- Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网 络应用程序框架,用以快速开发高性能、高可靠性的网络 IO 程序
- Netty 可以帮助你快速、简单的开发出一个网络应用,相当于简化和流程化了 NIO 的 开发过程
- Netty 是目前最流行的 NIO 框架,Netty 在互联网领域、大数据分布式计算领域、游 戏行业、通信行业等获得了广泛的应用,知名的 Elasticsearch 、Dubbo 框架内部都采 用了 Netty。
Netty的优点
Netty 对 JDK 自带的 NIO 的 API 进行了封装,解决了上述问题。
- 设计优雅:适用于各种传输类型的统一 API 阻塞和非阻塞 Socket;基于灵活且可扩展 的事件模型,可以清晰地分离关注点;高度可定制的线程模型 ——单线程,一个或多个 线程池.
- 使用方便:详细记录的 Javadoc,用户指南和示例;没有其他依赖项,JDK 5(Netty 3.x)或 6(Netty 4.x)就足够了。
- 高性能、吞吐量更高:延迟更低;减少资源消耗;最小化不必要的内存复制。
- 安全:完整的 SSL/TLS 和 StartTLS 支持。
- 社区活跃、不断更新:社区活跃,版本迭代周期短,发现的 Bug 可以被及时修复, 同时,更多的新功能会被加入
Netty版本说明
- netty版本分为 netty3.x 和 netty4.x、netty5.x
- 因为Netty5出现重大bug,已经被官网废弃了,目前推荐使用的是Netty4.x的稳定版本
- 目前在官网可下载的版本 netty3.x netty4.0.x 和 netty4.1.x
- 在本套课程中,我们讲解 Netty4.1.x 版本
5)加粗样式 netty 下载地址: https://bintray.com/netty/downloads/netty/
线程模型基本介绍
- 不同的线程模式,对程序的性能有很大影响,为了搞清Netty 线程模式,我们来系统 的讲解下 各个线程模式, 最后看看Netty 线程模型有什么优越性.
- 目前存在的线程模型有:
传统阻塞 I/O 服务模型
Reactor 模式 - 根据 Reactor 的数量和处理资源池线程的数量不同,有 3 种典型的实现:
• 单 Reactor 单线程;
• 单 Reactor 多线程;
• 主从 Reactor 多线程 - Netty 线程模式(Netty 主要基于主从 Reactor 多线程模型做了一定的改进,其中主从 Reactor 多线程模型有多个 Reactor)
传统阻塞 I/O 服务模型
工作原理图
黄色的框表示对象, 蓝色的框表示线程 白色的框表示方法(API)
模型特点
- 采用阻塞IO模式获取输入的数据
- 每个连接都需要独立的线程完成数据的输入,业务处理, 数据返回
问题分析
- 当并发数很大,就会创建大量的线程,占用很大系统资源
- 连接创建后,如果当前线程暂时没有数据可读,该线程 会阻塞在read 操作,造成线程资源浪费
Reactor 模式
针对传统阻塞 I/O 服务模型的 2 个缺点,解决方案:
- 基于 I/O 复用模型:多个连接共用一个阻塞对象,应用程序只需要在一个阻塞对象等待,无需阻塞等待所有连接。当某个连接有新的数据可以处理时,操作系统通知应 用程序,线程从阻塞状态返回,开始进行业务处理
Reactor 对应的叫法: 1. 反应器模式 2. 分发者模式(Dispatcher) 3. 通知者模式(notifier) - 基于线程池复用线程资源:不必再为每个连接创建线程,将连接完成后的业务处理 任务分配给线程进行处理,一个线程可以处理多个连接的业务
I/O 复用结合线程池,就是 Reactor 模式基本设计思想, 如图:
说明:
- Reactor 模式,通过一个或多个输 入同时传递给服务处理器的模式 (基于事件驱动)
- 服务器端程序处理传入的多个请求, 并将它们同步分派到相应的处理线程, 因此Reactor模式也叫 Dispatcher模式
- Reactor 模式使用IO复用监听事件, 收到事件后,分发给某个线程(进 程), 这点就是网络服务器高并发处理关键
Reactor 模式中核心组成:
- Reactor:Reactor 在一个单独的线程中运行,负责监听和分发事件,分发给适当的处 理程序来对 IO 事件做出反应。 它就像公司的电话接线员,它接听来自客户的电话并 将线路转移到适当的联系人;
- Handlers:处理程序执行 I/O 事件要完成的实际事件,类似于客户想要与之交谈的公 司中的实际官员。Reactor 通过调度适当的处理程序来响应 I/O 事件,处理程序执行 非阻塞操作。
Reactor 模式分类:
根据 Reactor 的数量和处理资源池线程的数量不同,有 3 种典型的实现
- 单 Reactor 单线程
- 单 Reactor 多线程
- 主从 Reactor 多线程
单 Reactor 单线程
方案说明:
- Select 是前面 I/O 复用模型介绍的标准网络编程 API,可以实现应用程序通过一个阻 塞对象监听多路连接请求
- Reactor 对象通过 Select 监控客户端请求事件,收到事件后通过 Dispatch 进行分发
- 如果是建立连接请求事件,则由 Acceptor 通过 Accept 处理连接请求,然后创建一个 Handler 对象处理连接完成后的后续业务处理
- 如果不是建立连接事件,则 Reactor 会分发调用连接对应的 Handler 来响应
- Handler 会完成 Read→业务处理→Send 的完整业务流程
方案优缺点分析:
- 优点:模型简单,没有多线程、进程通信、竞争的问题,全部都在一个线程中完成
- 缺点:性能问题,只有一个线程,无法完全发挥多核 CPU 的性能。Handler 在处理某 个连接上的业务时,整个进程无法处理其他连接事件,很容易导致性能瓶颈
- 缺点:可靠性问题,线程意外终止,或者进入死循环,会导致整个系统通信模块不 可用,不能接收和处理外部消息,造成节点故障
- 使用场景:客户端的数量有限,业务处理非常快速,比如 Redis在业务处理的时间复 杂度 O(1) 的情况
单Reactor多线程
方案说明
- Reactor 对象通过select 监控客户端请求 事件, 收到事件后,通过dispatch进行分发
- 如果建立连接请求, 则右Acceptor 通过 accept 处理连接请求, 然后创建一个Handler对象 处理完成连接后的各种事件
- 如果不是连接请求,则由reactor分发调用连接对 应的handler 来处理
- handler 只负责响应事件,不做具体的业务处理, 通过read 读取数据后,会分发给后面的worker线 程池的某个线程处理业务
- worker 线程池会分配独立线程完成真正的业务, 并将结果返回给handler
- handler收到响应后,通过send 将结果返回给 client
方案优缺点分析: - 优点:可以充分的利用多核cpu 的处理能力
- 缺点:多线程数据共享和访问比较复杂, reactor 处理所有的事件的监听和响应,在 单线程运行, 在高并发场景容易出现性能瓶颈
主从 Reactor 多线程
工作原理示意图:
针对单 Reactor 多线程模型中,Reactor 在单线程中运 行,高并发场景下容易成为性能瓶颈,可以让 Reactor 在多线程中运行
方案说明
- Reactor主线程 MainReactor 对象通过select 监听连接事件, 收 到事件后,通过Acceptor 处理连接事件
- 当 Acceptor 处理连接事件后,MainReactor 将连接分配给 SubReactor
- subreactor 将连接加入到连接队列进行监听,并创建handler 进行各种事件处理
- 当有新事件发生时, subreactor 就会调用对应的handler处 理
- handler 通过read 读取数据,分发给后面的worker 线程处理
- worker 线程池分配独立的worker 线程进行业务处理,并返 回结果
- handler 收到响应的结果后,再通过send将结果返回给client
- Reactor 主线程可以对应多个Reactor子线程,即MainReactor可以对应多个SubReactor。
方案优缺点说明:
- 优点:父线程与子线程的数据交互简单职责明确,父线程只需要接收新连接,子线 程完成后续的业务处理。
- 优点:父线程与子线程的数据交互简单,Reactor 主线程只需要把新连接传给子线 程,子线程无需返回数据。
- 缺点:编程复杂度较高
结合实例:
这种模型在许多项目中广泛使用,包括 Nginx 主从 Reactor 多进程模型, Memcached 主从多线程,Netty 主从多线程模型的支持
3 种模式用生活案例来理解
- 单 Reactor 单线程,前台接待员和服务员是同一个人,全程为顾客服
- 单 Reactor 多线程,1 个前台接待员,多个服务员,接待员只负责接待
- 主从 Reactor 多线程,多个前台接待员,多个服务生
Reactor 模式具有如下的优点:
- 响应快,不必为单个同步时间所阻塞,虽然 Reactor 本身依然是同步的
- 可以最大程度的避免复杂的多线程及同步问题,并且避免了多线程/进程 的切换开销
- 扩展性好,可以方便的通过增加 Reactor 实例个数来充分利用 CPU 资源
- 复用性好,Reactor 模型本身与具体事件处理逻辑无关,具有很高的复用性
Netty模型
工作原理示意图1-简单版
Netty 主要基于主从 Reactors 多线程模型(如图)做了一定的改进,其中主从 Reactor 多 线程模型有多个 Reactor
- BossGroup 线程维护Selector , 只关注Accecpt
- 当接收到Accept事件,获取到对应的 SocketChannel, 封装成 NIOScoketChannel并注册到 Worker 线程(事件循环), 并进行维护
- 当Worker线程监听到selector 中通道发生自己感 兴趣的事件后,就进行处理(就由handler), 注意 handler 已经加入到通道
工作原理示意图2-进阶版
Netty 主要基于主从 Reactors 多线程模型(如 图)做了一定的改进,其 中主从 Reactor 多线程模 型有多个 Reactor
工作原理示意图-详细版
- Netty抽象出两组线程池 BossGroup 专门负责接收客户端的连接, WorkerGroup 专门负责网络的读写
- BossGroup 和 WorkerGroup 类型都是 NioEventLoopGroup
- NioEventLoopGroup 相当于一个事件循环组, 这个组中含有多个事件循 环 ,每一个事件循环是 NioEventLoop
- NioEventLoop 表示一个不断循环的执行处理任务的线程, 每个 NioEventLoop 都有一个selector , 用于监听绑定在其上的socket的网络 通讯
- NioEventLoopGroup 可以有多个线程, 即可以含有多个NioEventLoop
- 每个Boss NioEventLoop 循环执行的步骤有3步
(1) 轮询accept 事件
(2)处理accept 事件 , 与client建立连接 , 生成NioScocketChannel , 并将其 注册到某个worker NIOEventLoop 上的 selector
(3) 处理任务队列的任务 , 即 runAllTasks - 每个 Worker NIOEventLoop 循环执行的步骤
(1)轮询read, write 事件
(2)处理i/o事件, 即read , write 事件,在对应NioScocketChannel 处理
(3)处理任务队列的任务 , 即 runAllTasks - 每个Worker NIOEventLoop 处理业务时,会使用pipeline(管道), pipeline中包含了channel,即通过pipeline可以获取到对应的通道,管道中维护了很多的处理器
Netty快速入门实例-TCP服务
- 实例要求:使用IDEA 创建Netty项目
- Netty 服务器在 6668 端口监听,客户端能发送消息给服务器 “hello, 服务器~”
- 服务器可以回复消息给客户端 “hello, 客户端~”
- 目的:对Netty 线程模型 有一个初步认识, 便于理解Netty 模型理论
- 看代码演示
5.1 编写服务端
5.2 编写客户端
5.3 对netty 程序进行分析,看看netty模型特点
服务器端:
public class NettyServer {public static void main(String[] args) throws Exception {//创建BossGroup 和WorkGroup//说明//1、创建两个线程组:BossGroup 和WorkGroup//2、BossGroup只处理连接请求,真正的客户端业务处理会交给WorkGroup//3、两个都是无限循环NioEventLoopGroup bossGroup = new NioEventLoopGroup();NioEventLoopGroup workerGroup = new NioEventLoopGroup();try {//创建服务器端的启动对象,配置参数ServerBootstrap bootstrap = new ServerBootstrap();//使用链式编程来进行设置bootstrap.group(bossGroup, workerGroup)//设置两个线程组.channel(NioServerSocketChannel.class)//使用NioServerSocketChannel 作为服务器的通道实现.option(ChannelOption.SO_BACKLOG, 128)//设置线程队列得到的连接个数.childOption(ChannelOption.SO_KEEPALIVE, true)//设置保持活动连接的个数.childHandler(new ChannelInitializer<SocketChannel>() {//创建通道初始化对象(匿名对象)//给pipeline设置处理器@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ch.pipeline().addLast(new NettyServerHandler());}});//给我们的workerGroup的 EventLoop 对应的管道设置处理器System.out.println(".....服务器 is ready.....");//绑定一个端口并且同步,生成一个ChannelFuture对象//启动服务器(并绑定端口)ChannelFuture cf = bootstrap.bind(6668).sync();//对关闭通道进行监听cf.channel().closeFuture().sync();}finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}
}/*说明:1、自定义的handler需要继承netty规定的某个适配器HandlerAdapter,比如ChannelInboundHandlerAdapter2、这时自定义的handler才能成为一个handler*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {//读取数据事件(这里我们可以读取客户端发来的数据)/*1、ChannelHandlerContext ctx:上下文对象,含有pipeline ,通道channel ,地址等信息2、 Object msg,客户端发送的数据,默认是Object*/@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {System.out.println("server ctx = "+ ctx);//将msg转为ByteBuf//ByteBuf是netty提供的,不是NIO的bytebufferByteBuf buf =(ByteBuf) msg;System.out.println("客户端发送的消息是:"+ buf.toString(CharsetUtil.UTF_8));System.out.println("客户端地址是:"+ctx.channel().remoteAddress());}//数据读取完毕,响应给客户端@Overridepublic void channelReadComplete(ChannelHandlerContext ctx) throws Exception {//将数据写入缓冲并刷新至管道ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端",CharsetUtil.UTF_8));}//处理异常,一般是关闭通道@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {ctx.close();}
}
客户端:
public class NettyServer {public static void main(String[] args) throws Exception {//创建BossGroup 和WorkGroup//说明//1、创建两个线程组:BossGroup 和WorkGroup//2、BossGroup只处理连接请求,真正的客户端业务处理会交给WorkGroup//3、两个都是无限循环NioEventLoopGroup bossGroup = new NioEventLoopGroup();NioEventLoopGroup workerGroup = new NioEventLoopGroup();try {//创建服务器端的启动对象,配置参数ServerBootstrap bootstrap = new ServerBootstrap();//使用链式编程来进行设置bootstrap.group(bossGroup, workerGroup)//设置两个线程组.channel(NioServerSocketChannel.class)//使用NioServerSocketChannel 作为服务器的通道实现.option(ChannelOption.SO_BACKLOG, 128)//设置线程队列得到的连接个数.childOption(ChannelOption.SO_KEEPALIVE, true)//设置保持活动连接的个数.childHandler(new ChannelInitializer<SocketChannel>() {//创建通道初始化对象(匿名对象)//给pipeline设置处理器@Overrideprotected void initChannel(SocketChannel ch) throws Exception {ch.pipeline().addLast(new NettyServerHandler());}});//给我们的workerGroup的 EventLoop 对应的管道设置处理器System.out.println(".....服务器 is ready.....");//绑定一个端口并且同步,生成一个ChannelFuture对象//启动服务器(并绑定端口)ChannelFuture cf = bootstrap.bind(6668).sync();//对关闭通道进行监听cf.channel().closeFuture().sync();}finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}
}/*说明:1、自定义的handler需要继承netty规定的某个适配器HandlerAdapter,比如ChannelInboundHandlerAdapter2、这时自定义的handler才能成为一个handler*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {//读取数据事件(这里我们可以读取客户端发来的数据)/*1、ChannelHandlerContext ctx:上下文对象,含有pipeline ,通道channel ,地址等信息2、 Object msg,客户端发送的数据,默认是Object*/@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {System.out.println("server ctx = "+ ctx);//将msg转为ByteBuf//ByteBuf是netty提供的,不是NIO的bytebufferByteBuf buf =(ByteBuf) msg;System.out.println("客户端发送的消息是:"+ buf.toString(CharsetUtil.UTF_8));System.out.println("客户端地址是:"+ctx.channel().remoteAddress());}//数据读取完毕,响应给客户端@Overridepublic void channelReadComplete(ChannelHandlerContext ctx) throws Exception {//将数据写入缓冲并刷新至管道ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端",CharsetUtil.UTF_8));}//处理异常,一般是关闭通道@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {ctx.close();}
}
启动服务器和客户端:
上述代码分析:
1、首选分析BossGroup和BossGroup的线程数(NioEventLoop)
BossGroup和BossGroup含有子线程(NioEventLoop)的个数,默认是CPU核数*2
我们打印一下看看【NettyRuntime.availableProcessors() * 2】值是多少(博主的计算机是4核的)
public class test {public static void main(String[] args) {System.out.println(NettyRuntime.availableProcessors() * 2);}
}
这就说明上述服务器端BossGroup和workerGroup各自含有8个子线程(NioEventLoop)。
每个NioEventLoop其实最终是通过EventExcutor进行处理的
BossGroup一般线程数不需要太多,因为它就负责客户端的连接请求,加入我们现在只给BossGroup设置一个线程数(NioEventLoop),workerGroup默认8个线程(注意,博主的计算机是4核的,所以是默认8个),我们看下多个客户端连接我们的服务器时,workerGroup是怎么分配线程的。
NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);
NioEventLoopGroup workerGroup = new NioEventLoopGroup();
我们启动9个客户端:
结果:
.....服务器 is ready.....
服务器读取线程 nioEventLoopGroup-3-1
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0x87026232, L:/127.0.0.1:6668 - R:/127.0.0.1:51235])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51235
服务器读取线程 nioEventLoopGroup-3-2
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0xbb0bc3a0, L:/127.0.0.1:6668 - R:/127.0.0.1:51262])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51262
服务器读取线程 nioEventLoopGroup-3-3
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0x5d2ff2b4, L:/127.0.0.1:6668 - R:/127.0.0.1:51284])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51284
服务器读取线程 nioEventLoopGroup-3-4
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0xc69baf9b, L:/127.0.0.1:6668 - R:/127.0.0.1:51308])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51308
服务器读取线程 nioEventLoopGroup-3-5
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0x84d4b6d8, L:/127.0.0.1:6668 - R:/127.0.0.1:51336])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51336
服务器读取线程 nioEventLoopGroup-3-6
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0x93e4c384, L:/127.0.0.1:6668 - R:/127.0.0.1:51364])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51364
服务器读取线程 nioEventLoopGroup-3-7
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0x3e91011c, L:/127.0.0.1:6668 - R:/127.0.0.1:51389])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51389
服务器读取线程 nioEventLoopGroup-3-8
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0x7ac03d14, L:/127.0.0.1:6668 - R:/127.0.0.1:51413])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51413
服务器读取线程 nioEventLoopGroup-3-1
server ctx = ChannelHandlerContext(NettyServerHandler#0, [id: 0x67a17b1b, L:/127.0.0.1:6668 - R:/127.0.0.1:51436])
客户端发送的消息是:hello,server:喵
客户端地址是:/127.0.0.1:51436
最终发现服务器会把workerGroup中的8个线程轮询分配给客户端
任务队列中的 Task 有 3 种典型使用场景
- 用户程序自定义的普通任务
- 用户自定义定时任务
- 非当前 Reactor 线程调用 Channel 的各种方法
例如在推送系统的业务线程里面,根据用户的标识,找到对应的 Channel 引用,然后 调用 Write 类方法向该用户推送消息,就会进入到这种场景。最终的 Write 会提交到 任务队列中后被异步消费
taskQueue自定义任务
taskQueue(任务队列)是Netty中NioeventLoop中的一个重要的组件,因为一个NioEventLoop就对应一个线程,因此任务队列是线程私有的
提出问题
任务队列可以实现task的异步消费,异步性是netty解决网络大并发的一个关键,对于之前写的netty入门案例中,如果服务器端的某个NioEventLoop需要处理一个比较耗时的处理时,客户端就会被阻塞等待服务器的响应,我们把之前服务器端处理器的代码改一下:
public class NettyServerHandler extends ChannelInboundHandlerAdapter {//读取数据事件(这里我们可以读取客户端发来的数据)/*1、ChannelHandlerContext ctx:上下文对象,含有pipeline ,通道channel ,地址等信息2、 Object msg,客户端发送的数据,默认是Object*/@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {Thread.sleep(10*1000);ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端1",CharsetUtil.UTF_8));// System.out.println("服务器读取线程 "+Thread.currentThread().getName());
// System.out.println("server ctx = "+ ctx);
// System.out.println("看看channel和pipeline的关系");
// ChannelPipeline pipeline = ctx.pipeline();//pipeline本质是一个双向链表
//
// //将msg转为ByteBuf
// //ByteBuf是netty提供的,不是NIO的bytebuffer
// ByteBuf buf =(ByteBuf) msg;
// System.out.println("客户端发送的消息是:"+ buf.toString(CharsetUtil.UTF_8));
// System.out.println("客户端地址是:"+ctx.channel().remoteAddress());}//数据读取完毕,响应给客户端@Overridepublic void channelReadComplete(ChannelHandlerContext ctx) throws Exception {//将数据写入缓冲并刷新至管道ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端2",CharsetUtil.UTF_8));}//处理异常,一般是关闭通道@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {ctx.close();}
}
重新启动服务器和客户端
我们发现客户端并没有立即收到服务器的响应,而是阻塞10秒后才响应
其实我们的客户端,仅仅是发一个“hello,server:喵”给服务器打个招呼,并不需要对服务器的处理结果做任何操作;
如果客户端需要对服务器的处理结果做二次操作,那么客户端发生阻塞也是合理的,但是想要解决这种阻塞,一般是通过mq消息对列进行异步处理,这不是我们讨论的范畴。
解决方案1:用户自定义的普通任务
package com.atguigu.netty.simple;import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelPipeline;
import io.netty.util.CharsetUtil;/*说明:1、自定义的handler需要继承netty规定的某个适配器HandlerAdapter,比如ChannelInboundHandlerAdapter2、这时自定义的handler才能成为一个handler*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {//读取数据事件(这里我们可以读取客户端发来的数据)/*1、ChannelHandlerContext ctx:上下文对象,含有pipeline ,通道channel ,地址等信息2、 Object msg,客户端发送的数据,默认是Object*/@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {//会把当前处理的任务放进taskQueue中(该任务队列先进先出)ctx.channel().eventLoop().execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(10*1000);ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端1 ",CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}});System.out.println("go on....");}//数据读取完毕,响应给客户端@Overridepublic void channelReadComplete(ChannelHandlerContext ctx) throws Exception {//将数据写入缓冲并刷新至管道ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端2",CharsetUtil.UTF_8));}//处理异常,一般是关闭通道@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {ctx.close();}
}
测试:
1、客户端再向服务器发送数据后,立马收到了服务器的响应(channelReadComplete)
2、10秒后收到任务处理完成的响应
验证确实往taskqueue中放了一个任务:
再创建一个任务:
@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {ctx.channel().eventLoop().execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(10*1000);ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端1 ",CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}});ctx.channel().eventLoop().execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(20*1000);ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端1 ",CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}});System.out.println("go on....");}
再测试
1、客户端发送数据后,立马收到服务器响应
2、10秒后收到第一个任务的响应
3、20秒后收到第二个任务的响应
说明两个task实际被放在一个任务队列中了,队列按照先进先出,并且服务器端只用一个线程处理这两个任务(这个也可以理解,它俩都在一个线程中的处理器中)
scheduleTaskQueue用户自定义定时任务
还是老样子,修改之前服务器端的处理器
package com.atguigu.netty.simple;import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelPipeline;
import io.netty.util.CharsetUtil;import java.util.concurrent.TimeUnit;/*说明:1、自定义的handler需要继承netty规定的某个适配器HandlerAdapter,比如ChannelInboundHandlerAdapter2、这时自定义的handler才能成为一个handler*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {//读取数据事件(这里我们可以读取客户端发来的数据)/*1、ChannelHandlerContext ctx:上下文对象,含有pipeline ,通道channel ,地址等信息2、 Object msg,客户端发送的数据,默认是Object*/@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {ctx.channel().eventLoop().schedule(new Runnable() {@Overridepublic void run() {try {Thread.sleep(5*1000);ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端3 ",CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}},5, TimeUnit.SECONDS);System.out.println("go on....");}//数据读取完毕,响应给客户端@Overridepublic void channelReadComplete(ChannelHandlerContext ctx) throws Exception {//将数据写入缓冲并刷新至管道ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端2",CharsetUtil.UTF_8));}//处理异常,一般是关闭通道@Overridepublic void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {ctx.close();}
}
上述创建了一个定时任务,5秒后执行,执行时间是5秒,客户端启动后,验证也是如此
我们玩个有意思的,把上面服务器处理器修改下,我们创建三个任务,一个是定时任务放在scheduleTaskQueue任务队列中,另外两个普通任务放在TaskQueue任务队列中。
场景1:我们把定时任务入队的代码写在普通任务之后
@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {ctx.channel().eventLoop().execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(10*1000);Date date = new Date();System.out.println(date.toString() );ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端1 "+date.toString(),CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}});ctx.channel().eventLoop().execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(20*1000);Date date = new Date();System.out.println(date.toString() );ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端1 "+date.toString(),CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}});ctx.channel().eventLoop().schedule(new Runnable() {@Overridepublic void run() {try {Thread.sleep(5*1000);Date date = new Date();System.out.println(date.toString() );ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端3 "+date.toString(),CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}},5, TimeUnit.SECONDS);System.out.println("go on....");}
客户端 ok...
clientChannelHandlerContext(NettyClientHandler#0, [id: 0x04cad703, L:/127.0.0.1:55739 - R:/127.0.0.1:6668])
服务器回复的消息:hello,客户端2
服务器的地址:/127.0.0.1:6668
服务器回复的消息:hello,客户端1 Fri May 20 02:08:58 CST 2022
服务器的地址:/127.0.0.1:6668
服务器回复的消息:hello,客户端2 Fri May 20 02:09:18 CST 2022
服务器的地址:/127.0.0.1:6668
服务器回复的消息:hello,客户端3 Fri May 20 02:09:23 CST 2022
服务器的地址:/127.0.0.1:6668
场景2:我们把定时任务入队代码写在两个普通任务的入队之前
@Overridepublic void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {ctx.channel().eventLoop().schedule(new Runnable() {@Overridepublic void run() {try {Thread.sleep(5*1000);Date date = new Date();System.out.println(date.toString() );ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端3 "+date.toString(),CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}},5, TimeUnit.SECONDS);ctx.channel().eventLoop().execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(10*1000);Date date = new Date();System.out.println(date.toString() );ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端1 "+date.toString(),CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}});ctx.channel().eventLoop().execute(new Runnable() {@Overridepublic void run() {try {Thread.sleep(20*1000);Date date = new Date();System.out.println(date.toString() );ctx.writeAndFlush(Unpooled.copiedBuffer("hello,客户端2 "+date.toString(),CharsetUtil.UTF_8));}catch (Exception e){System.out.println("发生异常:"+e.getMessage());}}});System.out.println("go on....");}
客户端 ok...
clientChannelHandlerContext(NettyClientHandler#0, [id: 0xf3293395, L:/127.0.0.1:55825 - R:/127.0.0.1:6668])
服务器回复的消息:hello,客户端2
服务器的地址:/127.0.0.1:6668
服务器回复的消息:hello,客户端1 Fri May 20 02:11:37 CST 2022
服务器的地址:/127.0.0.1:6668
服务器回复的消息:hello,客户端2 Fri May 20 02:11:57 CST 2022
服务器的地址:/127.0.0.1:6668
服务器回复的消息:hello,客户端3 Fri May 20 02:12:02 CST 2022
服务器的地址:/127.0.0.1:6668
经过多次测试出现以下现象:
1、无论定时任务是否比普通任务先入队,都是普通任务先执行
2、最后一个普通任务执行完后,5秒后定时任务直接响应
结论:
taskqueue的优先级要比scheduleTaskQueue要高,即使定时任务时间到了,也要等待taskqueue的任务执行完,才轮到它执行。
方案再说明
- Netty 抽象出两组线程池,BossGroup 专门负责接收客户端连接,WorkerGroup 专门负 责网络读写操作。
- NioEventLoop 表示一个不断循环执行处理任务的线程,每个 NioEventLoop 都有一个 selector,用于监听绑定在其上的 socket 网络通道。
- NioEventLoop 内部采用串行化设计,从消息的读取->解码->处理->编码->发送,始终由 IO 线程 NioEventLoop 负责
• NioEventLoopGroup 下包含多个 NioEventLoop
• 每个 NioEventLoop 中包含有一个 Selector,一个 taskQueue
• 每个 NioEventLoop 的 Selector 上可以注册监听多个 NioChannel
• 每个 NioChannel 只会绑定在唯一的 NioEventLoop 上
• 每个 NioChannel 都绑定有一个自己的 ChannelPipeline
异步模型
基本介绍
- 异步的概念和同步相对。当一个异步过程调用发出后,调用者不能立刻得到结果。实 际处理这个调用的组件在完成后,通过状态、通知和回调来通知调用者。
- Netty 中的 I/O 操作是异步的,包括 Bind、Write、Connect 等操作会简单的返回一个 ChannelFuture。
- 调用者并不能立刻获得结果,而是通过 Future-Listener 机制,用户可以方便的主动获 取或者通过通知机制获得 IO 操作结果
- Netty 的异步模型是建立在 future 和 callback 的之上的。callback 就是回调。重点说 Future,它的核心思想是:假设一个方法 fun,计算过程可能非常耗时,等待 fun返回 显然不合适。那么可以在调用 fun 的时候,立马返回一个 Future,后续可以通过 Future去监控方法 fun 的处理过程(即 : Future-Listener 机制)
Future 说明
- 表示异步的执行结果, 可以通过它提供的方法来检测执行是否完成,比如检索计算等等.
- ChannelFuture 是一个接口 : public interface ChannelFuture extends Future 我们可以添加监听器,当监听的事件发生时,就会通知到监听器.
工作原理示意图
说明:
- 在使用 Netty 进行编程时,拦截操作和转换出入站数据只需要您提供 callback 或利用 future 即可。这使得链式操作简单、高效, 并有利于编写可重用的、通用的代码。
- Netty 框架的目标就是让你的业务逻辑从网络基础应用编码中分离出来、解脱出来
示例
我们之前在编写服务器端代码和客户端代码的时候,很多处用到了异步模式,比如说服务器监听6668端口和关闭通道的时候:
或者客户端在连接服务器和关闭通道的时候:
Future-Listener 机制
当 Future 对象刚刚创建时,处于非完成状态,调用者可以通过返回的 ChannelFuture 来获取操作执行的状态,注册监听函数来执行完成后的操作。
常见有如下操作:
• 通过 isDone 方法来判断当前操作是否完成;
• 通过 isSuccess 方法来判断已完成的当前操作是否成功;
• 通过 getCause 方法来获取已完成的当前操作失败的原因;
• 通过 isCancelled 方法来判断已完成的当前操作是否被取消;
• 通过 addListener 方法来注册监听器,当操作已完成(isDone 方法返回完成),将会通知 指定的监听器;如果 Future 对象已完成,则通知指定的监听器举例说明 演示:绑定端口是异步操作,当绑定操作处理完,将会调用相应的监听器处理逻辑
//启动服务器(并绑定端口)ChannelFuture cf = bootstrap.bind(6668).sync();//给cf注册监听器cf.addListener(new ChannelFutureListener() {@Overridepublic void operationComplete(ChannelFuture future) throws Exception {if (cf.isSuccess()){System.out.println("监听端口成功");}else {System.out.println("监听端口失败");}}});
上述代码是给服务器监听6668这个行为写了一个监听器
启动服务器:
快速入门实例-HTTP服务
- 实例要求:使用IDEA 创建Netty项目
- Netty 服务器在 9336端口监听,浏览器发出请求 "http://localhost:9336/ "
- 服务器可以回复消息给客户端 "Hello! 我是服务器 5 " , 并 对特定请求资源进行过滤.
- 目的:Netty 可以做Http服务开发,并且理解Handler实例 和客户端及其请求的关系
public class TestServer {public static void main(String[] args) throws Exception {NioEventLoopGroup bossGroup = new NioEventLoopGroup(1);NioEventLoopGroup workerGroup = new NioEventLoopGroup();try {ServerBootstrap serverBootstrap = new ServerBootstrap();serverBootstrap.group(bossGroup,workerGroup).channel(NioServerSocketChannel.class).childHandler(new TestServerInitializer());ChannelFuture channelFuture = serverBootstrap.bind(9336).sync();channelFuture.channel().closeFuture().sync();}finally {bossGroup.shutdownGracefully();workerGroup.shutdownGracefully();}}
}public class TestServerInitializer extends ChannelInitializer<SocketChannel> {@Overrideprotected void initChannel(SocketChannel ch) throws Exception {//向管道加入处理器//得到管道ChannelPipeline pipeline = ch.pipeline();//加入一个netty提供的httpServerCodec codec=》[code+decoder]//httpServerCodec说明//是netty提供的处理http的编解码器pipeline.addLast("MyHttpServerCodec",new HttpServerCodec());//增加一个自定义的handlerpipeline.addLast("MyTestHttpServerHandler",new TestHttpServerHandler());}
}/*
说明
1. SimpleChannelInboundHandler 是 ChannelInboundHandlerAdapter
2. HttpObject 客户端和服务器端相互通讯的数据被封装成 HttpObject*/
public class TestHttpServerHandler extends SimpleChannelInboundHandler<HttpObject> {//channelRead0 读取客户端数据@Overrideprotected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {System.out.println("对应的channel=" + ctx.channel() + " pipeline=" + ctx.pipeline() + " 通过pipeline获取channel" + ctx.pipeline().channel());System.out.println("当前ctx的handler=" + ctx.handler());//判断 msg 是不是 httprequest请求if(msg instanceof HttpRequest) {System.out.println("ctx 类型="+ctx.getClass());System.out.println("pipeline hashcode" + ctx.pipeline().hashCode() + " TestHttpServerHandler hash=" + this.hashCode());System.out.println("msg 类型=" + msg.getClass());System.out.println("客户端地址" + ctx.channel().remoteAddress());//获取到HttpRequest httpRequest = (HttpRequest) msg;ByteBuf content = Unpooled.copiedBuffer("hello, 我是服务器", CharsetUtil.UTF_8);//构造一个http的相应,即 httpresponseFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());//将构建好 response返回ctx.writeAndFlush(response);}}}
对应的channel=[id: 0x47c58d20, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:65390] pipeline=DefaultChannelPipeline{(MyHttpServerCodec = io.netty.handler.codec.http.HttpServerCodec), (MyTestHttpServerHandler = com.atguigu.http.TestHttpServerHandler)} 通过pipeline获取channel[id: 0x47c58d20, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:65390]
当前ctx的handler=com.atguigu.http.TestHttpServerHandler@3d909997
ctx 类型=class io.netty.channel.DefaultChannelHandlerContext
pipeline hashcode549565176 TestHttpServerHandler hash=1032886679
msg 类型=class io.netty.handler.codec.http.DefaultHttpRequest
客户端地址/0:0:0:0:0:0:0:1:65390
对应的channel=[id: 0x47c58d20, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:65390] pipeline=DefaultChannelPipeline{(MyHttpServerCodec = io.netty.handler.codec.http.HttpServerCodec), (MyTestHttpServerHandler = com.atguigu.http.TestHttpServerHandler)} 通过pipeline获取channel[id: 0x47c58d20, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:65390]
当前ctx的handler=com.atguigu.http.TestHttpServerHandler@3d909997
对应的channel=[id: 0x47c58d20, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:65390] pipeline=DefaultChannelPipeline{(MyHttpServerCodec = io.netty.handler.codec.http.HttpServerCodec), (MyTestHttpServerHandler = com.atguigu.http.TestHttpServerHandler)} 通过pipeline获取channel[id: 0x47c58d20, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:65390]
当前ctx的handler=com.atguigu.http.TestHttpServerHandler@3d909997
ctx 类型=class io.netty.channel.DefaultChannelHandlerContext
pipeline hashcode549565176 TestHttpServerHandler hash=1032886679
msg 类型=class io.netty.handler.codec.http.DefaultHttpRequest
客户端地址/0:0:0:0:0:0:0:1:65390
对应的channel=[id: 0x47c58d20, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:65390] pipeline=DefaultChannelPipeline{(MyHttpServerCodec = io.netty.handler.codec.http.HttpServerCodec), (MyTestHttpServerHandler = com.atguigu.http.TestHttpServerHandler)} 通过pipeline获取channel[id: 0x47c58d20, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:65390]
当前ctx的handler=com.atguigu.http.TestHttpServerHandler@3d909997
发现客户端发送了两次请求,但是我明明点了一次,抓包看一下
需要把图标这次请求过滤掉
package com.atguigu.http;import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;import java.net.URI;/*
说明
1. SimpleChannelInboundHandler 是 ChannelInboundHandlerAdapter
2. HttpObject 客户端和服务器端相互通讯的数据被封装成 HttpObject*/
public class TestHttpServerHandler extends SimpleChannelInboundHandler<HttpObject> {//channelRead0 读取客户端数据@Overrideprotected void channelRead0(ChannelHandlerContext ctx, HttpObject msg) throws Exception {System.out.println("对应的channel=" + ctx.channel() + " pipeline=" + ctx.pipeline() + " 通过pipeline获取channel" + ctx.pipeline().channel());System.out.println("当前ctx的handler=" + ctx.handler());//判断 msg 是不是 httprequest请求if(msg instanceof HttpRequest) {System.out.println("ctx 类型="+ctx.getClass());System.out.println("pipeline hashcode" + ctx.pipeline().hashCode() + " TestHttpServerHandler hash=" + this.hashCode());System.out.println("msg 类型=" + msg.getClass());System.out.println("客户端地址" + ctx.channel().remoteAddress());//获取到HttpRequest httpRequest = (HttpRequest) msg;//获取uri, 过滤指定的资源URI uri = new URI(httpRequest.uri());if("/favicon.ico".equals(uri.getPath())) {System.out.println("请求了 favicon.ico, 不做响应");return;}//回复信息给浏览器 [http协议]ByteBuf content = Unpooled.copiedBuffer("hello, 我是服务器", CharsetUtil.UTF_8);//构造一个http的相应,即 httpresponseFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, content);response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/plain");response.headers().set(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());//将构建好 response返回ctx.writeAndFlush(response);}}}
对应的channel=[id: 0x0c3160ad, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:49285] pipeline=DefaultChannelPipeline{(MyHttpServerCodec = io.netty.handler.codec.http.HttpServerCodec), (MyTestHttpServerHandler = com.atguigu.http.TestHttpServerHandler)} 通过pipeline获取channel[id: 0x0c3160ad, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:49285]
当前ctx的handler=com.atguigu.http.TestHttpServerHandler@319851a0
ctx 类型=class io.netty.channel.DefaultChannelHandlerContext
pipeline hashcode1108707102 TestHttpServerHandler hash=832065952
msg 类型=class io.netty.handler.codec.http.DefaultHttpRequest
客户端地址/0:0:0:0:0:0:0:1:49285
对应的channel=[id: 0x0c3160ad, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:49285] pipeline=DefaultChannelPipeline{(MyHttpServerCodec = io.netty.handler.codec.http.HttpServerCodec), (MyTestHttpServerHandler = com.atguigu.http.TestHttpServerHandler)} 通过pipeline获取channel[id: 0x0c3160ad, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:49285]
当前ctx的handler=com.atguigu.http.TestHttpServerHandler@319851a0
对应的channel=[id: 0x0c3160ad, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:49285] pipeline=DefaultChannelPipeline{(MyHttpServerCodec = io.netty.handler.codec.http.HttpServerCodec), (MyTestHttpServerHandler = com.atguigu.http.TestHttpServerHandler)} 通过pipeline获取channel[id: 0x0c3160ad, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:49285]
当前ctx的handler=com.atguigu.http.TestHttpServerHandler@319851a0
ctx 类型=class io.netty.channel.DefaultChannelHandlerContext
pipeline hashcode1108707102 TestHttpServerHandler hash=832065952
msg 类型=class io.netty.handler.codec.http.DefaultHttpRequest
客户端地址/0:0:0:0:0:0:0:1:49285
请求了 favicon.ico, 不做响应
对应的channel=[id: 0x0c3160ad, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:49285] pipeline=DefaultChannelPipeline{(MyHttpServerCodec = io.netty.handler.codec.http.HttpServerCodec), (MyTestHttpServerHandler = com.atguigu.http.TestHttpServerHandler)} 通过pipeline获取channel[id: 0x0c3160ad, L:/0:0:0:0:0:0:0:1:9336 - R:/0:0:0:0:0:0:0:1:49285]
当前ctx的handler=com.atguigu.http.TestHttpServerHandler@319851a0
6、Netty 高性能架构设计相关推荐
- Netty 高性能架构设计
Netty 高性能架构设计 Netty 概述 原生 NIO 存在的问题 Netty 官网说明 Netty 的优点 Netty 版本说明 线程模型基本介绍 传统阻塞 I/O 服务模型 Reactor 模 ...
- 图解高性能服务器开发两种模式,第四章 NETTY高性能架构设计
目录 一.NIO存在问题以及Netty的优点 二.线程模型基本介绍 三.工作原理图(传统同步阻塞式IO) 四.Reactor模式 五.单Reactor单线程 六.单Reactor多线程 七.主从REA ...
- Netty高并发高性能架构设计NIO空轮训BUG
Netty高并发高性能架构设计&NIO空轮训BUG Netty高并发高性能架构设计 Netty线程模型 Netty主从Reactor模型设计的精髓 无锁串行化设计思想 零拷贝 直接内存 Net ...
- 【Netty源码解析】Netty核心源码和高并发、高性能架构设计精髓
Netty线程模型图 Netty线程模型源码剖析图 图链接:https://www.processon.com/view/link/5dee0943e4b079080a26c2ac Netty高并发高 ...
- 20个MySQL高性能架构设计原则(收藏版)
墨墨导读:MySQL如何实现高性能?以下内容是结合其他技术同仁的总结和自我实践整理的20个开源数据库设计原则,分享至此,希望对大家有帮助. 开源数据库架构设计原则 01 技术选型 选择成熟的平台和技术 ...
- 后台服务器高性能架构设计
作者:程序员小北 链接:https://www.nowcoder.com/discuss/568601?type=1&channel=-2&source_id=discuss_tag_ ...
- 【Elasticsearch】Elasticsearch 集群 运维 高性能 架构设计 高负载
1.概述 转载:干货 |<深入理解Elasticsearch>读书笔记 5.集群扩展 如何扩展集群? 5.1 垂直扩展 向Elasticsearch集群添加更多的资源.制约因素--如:JV ...
- 五、系统架构 - 高性能架构设计及性能优化
目录 性能测试 不同视角下的网站性能 性能指标 性能测试 性能测试报告 性能优化策略 前端性能优化 开启缓存 启用压缩 改代码 后端性能优化 分布式缓存 异步操作(消息队列) 使用集群 代码优化 SQ ...
- [强烈推荐] 新手入门:目前为止最透彻的的Netty高性能原理和框架架构解析
新手入门:目前为止最透彻的的Netty高性能原理和框架架构解析 1.引言 Netty 是一个广受欢迎的异步事件驱动的Java开源网络应用程序框架,用于快速开发可维护的高性能协议服务器和客户端. 本文基 ...
最新文章
- JavaScript面向对象怎样删除标签页?
- HttpServletRequest HttpServletResponse ServletException 重新打开后报红解决方法
- centos7 安装配置openstack-dashboard (官网openstack-juno版)
- 【数据结构笔记39】哈希表/散列表、(数据关键字/字符串关键字)散列构造函数
- think in java 读书笔记 1 ——移位
- python-opencv Harris 角点检测
- 暴风影音内MEE引擎揭秘
- 《Shell 脚本学习指南 》 -- 背景知识与入门 [第一、二章]
- Quartus仿真步骤
- python经济统计学论文_Python商务与经济统计学-1
- 手持式网络性能测试仪
- java查询SQL Server数据库条数
- 夜神模拟器如何设置自动代理
- oracle blob 24909,imp导入含blob字段的大表时不成功
- Simon‘s writting 全网最全笔记
- 仿小米通讯录 右侧滑动条与带动画的悬停列表实现(二)
- linux express 安装,linux下的node+express安装教程
- Android编译命令m、mm、mmm区别及工程搭建示例
- signature=e7b038f264f5a1cf5b8e81732b377b41,不同养生功法对2型糖尿病伴失眠患者抑郁,焦虑和睡眠质量的影响...
- linux fastQC 操作命令,Linux shell合并fastq测序数据/批量fastqc小脚本|merge|multiqc