文章目录
一、Netty基本介绍
1. 原生NIO存在的问题
- NIO 的类库和 API 繁杂,使用麻烦:需要熟练掌握 Selector、ServerSocketChannel、 SocketChannel、ByteBuffer等。
- 需要具备其他的额外技能:要熟悉 Java 多线程编程,因为 NIO 编程涉及到 Reactor 模式,你必须 对多线程和网络编程非常熟悉,才能编写出高质量的 NIO 程序。
- 开发工作量和难度都非常大:例如客户端面临断连重连、网络闪断、半包读写、失败缓存、网络拥 塞和异常流的处理等等。
- JDK NIO 的 Bug:臭名昭著的 Epoll Bug,它会导致 Selector 空轮询,最终导致 CPU 100%。直到 JDK 1.7版本该问题仍旧存在,没有被根本解决。
2. Netty是什么?
- Netty 是由 JBOSS 提供的一个 Java 开源框架。Netty 提供异步的、基于事件驱动的网络应用程序框架,用以快速开发高性能、高可靠性的网络 IO 程序。
- Netty 是一个基于 NIO 的网络编程框架,使用 Netty 可以帮助你快速、简单的开发出一个网络应用,相当于简化和流程化了 NIO 的开发过程。
3. Netty的优点
- 设计优雅,提供阻塞和非阻塞的 Socket;提供灵活可拓展的事件模型;提供高度可定制的线程模型。
- 具备更高的性能和更大的吞吐量,使用零拷贝技术最小化不必要的内存复制,减少资源的消耗。
- 提供安全传输特性。
- 支持多种主流协议;预置多种编解码功能,支持用户开发私有协议。
4. Netty的应用场景
Netty 在互联网领域、大数据分布式计算领域、游戏行业、 通信行业等获得了 广泛的应用,知名的 Elasticsearch 、Dubbo 框架内部都采用了 Netty。
二、线程模型
netty采用了线程模型,而不同的线程模型对程序的性能影响很大。所以接下来需要先了解线程模型,然后再学习Netty对应的线程模型。
1.线程模型有哪些?
- 传统阻塞 I/O 服务模型
- Reactor 模型
- 单 Reactor 单线程
- 单 Reactor 多线程
- 主从 Reactor 多线程
2. 各个线程模型介绍
2.1 传统阻塞I/O模型
工作模式:
采用阻塞 IO 模式获取输入的数据, 每个连接都需要独立的线程完成数据的输入 , 业务处理和数据返回工作。
存在问题
- 并发数大时,创建线程多,占用很多系统资源
- 连接创建后,没有数据传输,会造成线程阻塞在read函数,形成资源浪费。
2.2 Reactor模型
Reactor模型定义:
通过一个或多个输入同时传递给服务处理器的模式 , 服务器端程序处理传入的多个 请求,并将它们同步分派到相应的处理线程, 因此 Reactor 模式也叫 Dispatcher模式。
Reactor 模式使用 IO 复用监听事件, 收到事件后,分发给某个线程(进程), 这点就是网络服务器高并发处理关键。
-
单Reactor 单线程
工作模式:
-
Selector是可以实现应用程序通过一个阻塞对象监听多路连接请求。
-
Reactor 对象通过 Selector监控客户端请求事件,收到事件后通过 Dispatch 进行分发。
-
若Selector监听到的事件是建立连接请求事件,则由 Acceptor 通过 Accept 处理连接请求,然后创建一个 Handler 对象处理连接完成后的后续业务处理。
-
Handler 会完成 Read→业务处理→Send 的完整业务流程
优点:
模型简单,没有多线程、进程通信、竞争的问题,全部都在一个线程中完成
缺点:
- 性能问题: 只有一个线程,无法完全发挥多核 CPU 的性能。Handler 在处理某个连接上的业务时, 整个进程无法处理其他连接事件,很容易导致性能瓶颈
- 可靠性问题: 线程意外终止或者进入死循环,会导致整个系统通信模块不可用,不能接收和处理外部消息,造成节点故障
-
-
单Reactor 多线程
工作模式:
- Reactor 对象通过 selector 监控客户端请求事件, 收到事件后,通过 dispatch 进行分发
- 若Selector监听到的事件是建立连接请求事件, 则由 Acceptor 通过accept 处理连接请求
- 如果不是连接请求,则由 reactor 分发调用连接对应的 handler 来处理
- handler 只负责响应事件,不做具体的业务处理, 通过 read 读取数据后,会分发给后面的 worker 线程池的某个线程处理业务
- worker 线程池会分配独立线程完成真正的业务,并将结果返回给 handler
- handler 收到响应后,通过 send 将结果返回给 client
优点:
可以充分的利用多核 cpu 的处理能力
缺点:
reactor 处理所有的事件的监听和响应,在单线程中运行,这在高并发场景容易出现性能瓶颈
-
主从Reactor多线程
工作模式:
- Reactor 主线程 MainReactor 对象通过 select 监听客户端连接事件,收到事件后,通过 Acceptor 处理客户端连接事件
- 当 Acceptor 处理完客户端连接事件之后(与客户端建立好 Socket 连接),MainReactor 将 连接分配给 SubReactor。(即:MainReactor 只负责监听客户端连接请求,和客户端建立连 接之后将连接交由 SubReactor 监听后面的 IO 事件)
- SubReactor 将连接加入到自己的连接队列进行监听,并创建 Handler 对各种事件进行处理
- 当连接上有新事件发生的时候,SubReactor 就会调用对应的 Handler 处理
- Handler 通过 read 从连接上读取请求数据,将请求数据分发给 Worker 线程池进行业务处理
- Worker 线程池会分配独立线程来完成真正的业务处理,并将处理结果返回给 Handler。 Handler 通过 send 向客户端发送响应数据
- 一个 MainReactor 可以对应多个 SubReactor,即一个 MainReactor 线程可以对应多个 SubReactor 线程
优点:
- MainReactor 线程与 SubReactor 线程的数据交互简单职责明确,MainReactor 线程只需要 接收新连接,SubReactor 线程完成后续的业务处理
- MainReactor 线程与 SubReactor 线程的数据交互简单, MainReactor 线程只需要把新连接 传给 SubReactor 线程,SubReactor 线程无需返回数据
- 多个 SubReactor 线程能够应对更高的并发请求
缺点:
这种模式的缺点是编程复杂度较高。但是由于其优点明显,在许多项目中被广泛使用,包括 Nginx、Memcached、Netty 等。这种模式也被叫做服务器的 1+M+N 线程模式,即使用该模式开 发的服务器包含一个(或多个,1 只是表示相对较少)连接建立线程+M 个 IO 线程+N 个业务处理 线程。这是业界成熟的服务器程序设计模式。
三、Netty线程模型
Netty 的设计主要基于主从 Reactor 多线程模式,并做了一定的改进。
1. 简单版
工作模式:
- BossGroup 线程维护 Selector,ServerSocketChannel 注册到这个 Selector 上,只关注连接 建立请求事件(主 Reactor)
- 当接收到来自客户端的连接建立请求事件的时候,通过 ServerSocketChannel.accept 方法获得对应的 SocketChannel,并封装成 NioSocketChannel 注册到 WorkerGroup 线程中的 Selector,每个 Selector 运行在一个线程中(从 Reactor)
- 当 WorkerGroup 线程中的 Selector 监听到自己感兴趣的 IO 事件后,就调用 Handler 处理
2. 进阶版
工作模式:
- 有两组线程池:BossGroup 和 WorkerGroup,BossGroup 中的线程专门负责和客户端建立 连接,WorkerGroup 中的线程专门负责处理连接上的读写
- BossGroup 和 WorkerGroup 含有多个不断循环的执行事件处理的线程,每个线程都包含一 个 Selector,用于监听注册在其上的 Channel
- 每个 BossGroup 中的线程循环执行以下三个步骤
- 轮询注册在其上的 ServerSocketChannel 的 accept 事件(OP_ACCEPT 事件)
- 处理 accept 事件,与客户端建立连接,生成一个 NioSocketChannel,并将其注册到 WorkerGroup 中某个线程上的 Selector 上
- 再去以此循环处理任务队列中的下一个事件
- 每个 WorkerGroup 中的线程循环执行以下三个步骤
- 轮训注册在其上的 NioSocketChannel 的 read/write 事件(OP_READ/OP_WRITE 事 件)
- 在对应的 NioSocketChannel 上处理 read/write 事件
- 再去以此循环处理任务队列中的下一个事件
3. 详细版
工作模式:
- Netty抽象两组线程池:BosssGroup 和 WorkerGroup,也可以叫做 BossNioEventLoopGroup 和 WorkerNioEventLoopGroup。每个线程池中都有 NioEventLoop 线程。BossGroup 中的线程专门负责和客户端建立连接,WorkerGroup 中的 线程专门负责处理连接上的读写。BossGroup 和 WorkerGroup 的类型都是 NioEventLoopGroup
- NioEventLoopGroup 相当于一个事件循环组,这个组中含有多个事件循环,每个事件循环就 是一个 NioEventLoop。
- NioEventLoop 表示一个不断循环的执行事件处理的线程,每个 NioEventLoop 都包含一个 Selector,用于监听注册在其上的 Socket 网络连接(Channel)。
- NioEventLoopGroup 可以含有多个线程,即可以含有多个 NioEventLoop
- 每个 BossNioEventLoop 中循环执行以下三个步骤
- select:轮询注册在其上的 ServerSocketChannel 的 accept 事件(OP_ACCEPT 事件)
- processSelectedKeys:处理 accept 事件,与客户端建立连接,生成一个 NioSocketChannel,并将其注册到某个 WorkerNioEventLoop 上的 Selector 上
- runAllTasks:再去以此循环处理任务队列中的其他任务
- 每个 WorkerNioEventLoop 中循环执行以下三个步骤
- select:轮询注册在其上的 NioSocketChannel 的 read/write 事件 (OP_READ/OP_WRITE 事件)
- processSelectedKeys:在对应的 NioSocketChannel 上处理 read/write 事件
- runAllTasks:再去以此循环处理任务队列中的其他任务
- 在以上两个processSelectedKeys步骤中,会使用 Pipeline(管道),Pipeline 中引用了 Channel,即通过 Pipeline 可以获取到对应的 Channel,Pipeline 中维护了很多的处理器 (拦截处理器、过滤处理器、自定义处理器等)。
四、Netty的基本使用
1. 核心API介绍
-
ChannelHandler 及其实现类
-
ChannelHandler接口定义了许多事件处理的方法,我们可以通过重写这些方法去实现具体的业务逻辑。
-
类结构图:
-
Netty开发中需要自定义一个 Handler 类去实现 ChannelHandle接口或其子接口或其实现类,然后通过重写相应方法实现业务逻辑。我们接下来看看一般都需要重写哪些方法:
方法 介绍 public void channelActive(ChannelHandlerContext ctx) 通道就绪事件 public void channelRead(ChannelHandlerContext ctx, Object msg) 通道读取数据事件 public void channelReadComplete(ChannelHandlerContext ctx) 数据读取完毕事件 public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) 通道发生异常事 件
-
-
ChannelPiepeline
- ChannelPipeline 是一个 Handler 的集合,它负责处理和拦截 inbound 或者 outbound 的事件和操作,相当于一个贯穿 Netty 的责任链.
- ChannelHandler分类:
- ChannelInboundHandler:只处理消息入站
- ChannelOutboundHandler:只处理消息出站
- 混合型handler(即实现了ChannelOutboundHandler 和 ChannelInboundHandler两个类):既可以处理入站信息,又可以处理出站信息。
- InboundHandler是按照Pipleline的加载顺序的顺序执行, OutboundHandler 是按照Pipeline的加载顺序的逆序执行 :
- 假设pipleline加载的handler集合为:handler1(混合)、handler2(ChannelOutboundHandler)、handler3(ChannelInboundHandler)、handler4(ChannelInboundHandler)
- 客户端向服务端发送消息时,客户端消息出站 经过 handler2 --> handler1,服务器消息入站 经过 hanlder1 --> handler3 --> handler4
- 服务端向客户端响应消息时,服务端消息出站 经过 handler2 --> handler1,客户器消息入站 经过 hanlder1 --> handler3 --> handler4
-
ChannelHandlerContext
这 是 事 件 处 理 器 上 下 文 对 象 , Pipeline 链 中 的 实 际 处 理 节 点 。 每 个 处 理 节 点 ChannelHandlerContext 中 包 含 一 个 具 体 的 事 件 处 理 器 ChannelHandler ,同时 ChannelHandlerContext 中也绑定了对应的 ChannelPipeline和 Channel 的信息,方便对 ChannelHandler 进行调用。
常用方法:
方法 介绍 ChannelFuture close() 关闭通道 ChannelOutboundInvoker flush() 刷新 ChannelFuture writeAndFlush(Object msg) 将 数 据 写 到 ChannelPipeline 中 当 前 ChannelHandler 的下一个 ChannelHandler 开始处理(出站) -
ChannelOption
Netty 在创建 Channel 实例后,一般都需要设置 ChannelOption 参数。
方法 介绍 ChannelOption.SO_BACKLOG 服务端处理 客户端连接请求是顺序处理的,所以同一时间只能处理一个客户端连接。多个客户端来的时候,服 务端将不能处理的客户端连接请求放在队列中等待处理,backlog 参数指定了队列的大小。 ChannelOption.SO_KEEPALIVE 一直保持连接活动状态。该参数用于设置TCP连接,当设置该选项以后,会测试连接的状态,这个选项用于可能长时间没有数据交流的连接。当设置该选项以后,如果在两小时内没有数据的通信时,TCP会自动发送一个活动探测数据报文。 -
ChannelFuture
表示 Channel 中异步 I/O 操作的结果,在 Netty 中所有的 I/O 操作都是异步的,I/O 的调用会直接返回,调用者并不能立刻获得结果,但是可以通过 ChannelFuture 来获取 I/O 操作的处理状态。
方法 介绍 Channel channel() 返回当前正在进行 IO 操作的通道 ChannelFuture sync() 等待异步操作执行完毕,将异步改为同步 -
EventLoopGroup和实现类NioEventLoopGroup
- EventLoopGroup 是一组 EventLoop 的抽象,Netty 为了更好的利用多核 CPU 资源,一般 会有多个 EventLoop 同时工作,每个 EventLoop 维护着一个 Selector 实例。
- EventLoopGroup 提供 next 接口,可以从组里面按照一定规则获取其中一个 EventLoop 来处理任 务。在 Netty 服务器端编程中,我们一般都需要提供两个 EventLoopGroup,例如: BossEventLoopGroup 和 WorkerEventLoopGroup。 通常一个服务端口即一个 ServerSocketChannel 对应一个Selector 和一个EventLoop线程。 BossEventLoop 负责接收客户端的连接并将 SocketChannel 交给 WorkerEventLoopGroup 来进 行 IO 处理。
- BossEventLoopGroup 通常是一个单线程的 EventLoop,EventLoop 维护着一个注册了 ServerSocketChannel 的 Selector 实例,BossEventLoop 不断轮询 Selector 将连接事件分离出来, 通 常是 OP_ACCEPT 事件,然后将接收到的 SocketChannel 交给 WorkerEventLoopGroup, WorkerEventLoopGroup 会由 next 选择其中一个 EventLoop 来将这个 SocketChannel 注册到其维护的 Selector 并对其后续的 IO 事件进行处理。
- 一般情况下我们都是用实现类NioEventLoopGroup.
方法 介绍 public NioEventLoopGroup() 构造方法,创建线程组 public Future shutdownGracefully() 断开连接,关闭线程 -
ServerBootstrap 和 Bootstrap
- ServerBootstrap 是 Netty 中的服务器端启动助手,通过它可以完成服务器端的各种配置;
- Bootstrap 是 Netty 中的客户端启动助手,通过它可以完成客户端的各种配置。
方法 | 介绍 |
---|---|
public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) | 该方法用于服务器端,用来设置两个 EventLoop |
public B group(EventLoopGroup group) | 该方法用于客户端,用来设置一个 EventLoop |
public B channel(Class channelClass) | 该方法用来设置一个服务器端的通道 实现 |
public B option(ChannelOption option, T value) | 用来给 ServerChannel 添加配置 |
public ServerBootstrap childOption(ChannelOption childOption, T value) | 用来给接收到的通 道添加配置 |
public ServerBootstrap childHandler(ChannelHandler childHandler | 该方法用来设置业务 处 理类(自定义的 handler) |
public ChannelFuture bind(int inetPort) | 该方法用于服务器端,用来设置占用的端口号 |
public ChannelFuture connect(String inetHost, int inetPort) | 该方法用于客户端,用来连接服 务器端 |
-
Unpooled
这是 Netty 提供的一个专门用来操作缓冲区的工具类 。
方法 介绍 public static ByteBuf copiedBuffer(CharSequence string, Charset charset) 通过给定的数据 和 字符编码返回一个 ByteBuf 对象(类似于 NIO 中的 ByteBuffer 对象)
2. 案例
- 导入Netty的jar包
<dependencies>
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.42.Final</version>
</dependency>
</dependencies>
-
服务端:
-
步骤:
- 创建bossGroup线程组: 处理网络事件–连接事件
- 创建workerGroup线程组: 处理网络事件–读写事件
- 创建服务端启动助手
- 设置bossGroup线程组和workerGroup线程组
- 设置服务端通道实现为NIO
- 参数设置
- 创建一个通道初始化对象
- 向pipeline中添加自定义业务处理handler
- 启动服务端并绑定端口,同时将异步改为同步
- 关闭通道和关闭连接池
-
实现代码:
-
public class Server {
public static void main(String[] args) throws InterruptedException {
//1. 创建bossGroup线程组: 处理网络事件--连接事件
EventLoopGroup bossGroup = new NioEventLoopGroup();
//2. 创建workerGroup线程组: 处理网络事件--读写事件
EventLoopGroup workerGroup = new NioEventLoopGroup();
//3. 创建服务端启动助手
ServerBootstrap serverBootstrap = new ServerBootstrap();
//4. 设置bossGroup线程组和workerGroup线程组
serverBootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)//5. 设置服务端通道实现为NIO
.option(ChannelOption.SO_BACKLOG, 128)//6. 参数设置,消息排队队列的消息个数
.childOption(ChannelOption.SO_KEEPALIVE, Boolean.TRUE)//6. 参数设置,测试连接状态
.childHandler(new ChannelInitializer<SocketChannel>() {//7. 创建一个通道初始化对象
@Override
protected void initChannel(SocketChannel channel) throws Exception {
//8. 向pipeline中添加自定义业务处理handler
channel.pipeline().addLast(new NettyServerHandler());
}
});
//9. 启动服务端并绑定端口,同时将异步改为同步,绑定端口的操作需要成功后再执行后续操作
ChannelFuture channelFuture = serverBootstrap.bind(9988).sync();
System.out.println("server start...");
//10. 关闭通道(并不是真正意义上的关闭,而是监听通道关闭状态)和关闭连接池
channelFuture.channel().closeFuture().sync();
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
自定义handler处理器部分:
public class NettyServerHandler implements ChannelInboundHandler {
@Override
public void channelActive(ChannelHandlerContext channelHandlerContext) throws Exception {
}
//通道读取事件
@Override
public void channelRead(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {
ByteBuf byteBuf = (ByteBuf) o;
System.out.println("客户端消息:" + byteBuf.toString(CharsetUtil.UTF_8));
}
//读取完毕
@Override
public void channelReadComplete(ChannelHandlerContext channelHandlerContext) throws Exception {
channelHandlerContext.writeAndFlush(Unpooled.copiedBuffer("hello,nettyClient...", CharsetUtil.UTF_8));
}
//异常发生事件
@Override
public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable throwable) throws Exception {
throwable.printStackTrace();
channelHandlerContext.close();
}
@Override
public void channelRegistered(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void channelUnregistered(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void channelInactive(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void userEventTriggered(ChannelHandlerContext channelHandlerContext, Object o) throws Exception {
}
@Override
public void channelWritabilityChanged(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void handlerAdded(ChannelHandlerContext channelHandlerContext) throws Exception {
}
@Override
public void handlerRemoved(ChannelHandlerContext channelHandlerContext) throws Exception {
}
}
-
客户端:
-
步骤:
-
创建线程组
-
创建客户端启动助手
-
设置线程组
-
设置客户端通道实现为NIO
-
创建一个通道初始化对象
-
向pipeline中添加自定义业务处理handler
-
启动客户端,等待连接服务端,同时将异步改为同步
-
关闭通道和关闭连接池
-
-
实现代码:
public class Client { public static void main(String[] args) throws InterruptedException { //1. 创建线程组 EventLoopGroup group = new NioEventLoopGroup(); //2. 创建客户端启动助手 Bootstrap bootstrap = new Bootstrap(); //3. 设置线程组 bootstrap.group(group) .channel(NioSocketChannel.class)//4. 设置客户端通道实现为NIO .handler(new ChannelInitializer<>() {//5. 创建一个通道初始化对象 @Override protected void initChannel(Channel channel) throws Exception { //6. 向pipeline中添加自定义业务处理handler channel.pipeline().addLast(new NettyClientHandler()); } }); //7. 启动客户端,等待连接服务端,同时将异步改为同步 ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9988).sync(); //8. 关闭通道和关闭连接池 channelFuture.channel().closeFuture().sync(); group.shutdownGracefully(); } }
自定义handler处理器:
public class NettyClientHandler implements ChannelInboundHandler { //通道就绪 @Override public void channelActive(ChannelHandlerContext channelHandlerContext) throws Exception { channelHandlerContext.writeAndFlush(Unpooled.copiedBuffer("hello,nettyServer...", CharsetUtil.UTF_8)); } //通道读事件 @Override public void channelRead(ChannelHandlerContext channelHandlerContext, Object o) throws Exception { ByteBuf byteBuf = (ByteBuf) o; System.out.println("服务端消息:" + byteBuf.toString(CharsetUtil.UTF_8)); } @Override public void channelRegistered(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void channelUnregistered(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void channelInactive(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void channelReadComplete(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void userEventTriggered(ChannelHandlerContext channelHandlerContext, Object o) throws Exception { } @Override public void channelWritabilityChanged(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void handlerAdded(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void handlerRemoved(ChannelHandlerContext channelHandlerContext) throws Exception { } @Override public void exceptionCaught(ChannelHandlerContext channelHandlerContext, Throwable throwable) throws Exception { } }
-
-
测试结果:
总结
- netty封装了原生的NIO,简化了socket编程。
- Netty 是一个异步的、基于事件驱动的网络应用程序框架,用以快速开发高性能、高可靠性的网络 IO 程序。
- Netty基于主从Reactor模型做了改进,BossGroup 中的线程专门负责和客户端建立连接,WorkerGroup 中的 线程专门负责处理连接上的读写,Pipeline 中引用了 Channel,即通过 Pipeline 可以获取到对应的 Channel, Pipeline 中维护了很多的处理器 (拦截处理器、过滤处理器、自定义处理器等)。
- 关于Netty一些高级应用敬请期待~