一、Netty 工作原理示意图-简单版
Netty 主要基于主从 Reactors 多线程模型(如图) 做了一定的改进, 其中主从 Reactor 多线程模型有多个 Reactor
图解说明:
(1)BossGroup 线程维护 Selector , 只关注Accecpt;
(2)当接收到Accept事件, 获取到对应的 SocketChannel, 封装成 NIOScoketChannel并注册到 Worker 线程(事件循环), 并进行维护;
(3)当Worker线程监听到 selector 中通道发生自己感兴趣的事件后,就进行处理(由handler处理), 注意 handler 已经加入到通道;
二、Netty 工作原理示意图-进阶版
Netty 主要基于主从Reactors 多线程模型(如图) 做了一定的改进, 其中主从 Reactor 多线程模型有多个 Reactor
三、Netty 工作原理示意图-详细版
图解说明:
(1)Netty抽象出两组线程池 BossGroup 专门负责接收客户端的连接,WorkerGroup 专门负责网络的读写;
(2)BossGroup 和 WorkerGroup 类型都是 NioEventLoopGroup;
(3)NioEventLoopGroup 相当于一个事件循环组, 这个组中含有多个事件循环,每一个事件循环是 NioEventLoop;
(4)NioEventLoop 表示一个不断循环的执行处理任务的线程,每个NioEventLoop 都有一个selector, 用于监听绑定在其上的socket的网络通讯;
(5)NioEventLoopGroup 可以有多个线程, 即可以含有多个NioEventLoop;
(6)每个Boss 中的 NioEventLoop 循环执行的步骤有3步:
① 轮询 accept 事件;
② 处理 accept 事件,与 client 建立连接,生成 NioScocketChannel,并将其注册到某个worker 的 NIOEventLoop 上的 selector;
③ 处理任务队列的任务,即 runAllTasks;
(7)每个 Worker 中 NIOEventLoop 循环执行的步骤
① 轮询read, write 事件;
② 处理i/o事件, 即 read, write 事件, 在对应 NioScocketChannel 处理;
③ 处理任务队列的任务,即 runAllTasks;
(8)每个Worker NIOEventLoop 处理业务时, 会使用pipeline(管道), pipeline 中包含了 channel,即通过 pipline 可以获取到对应通道,管道中维护了很多的处理器;
四、Netty 快速入门实例-TCP服务
1、实例要求
- 使用 IDEA 创建 Netty 项目
- Netty 服务器在 6668 端口监听,客户端能发送消息给服务器 "hello, 服务器~"
- 服务器可以回复消息给客户端 "hello, 客户端~"
- 目的: 对 Netty 线程模型有一个初步认识, 便于理解Netty 模型理论
- 编写步骤
① 编写服务端
② 编写客户端
③ 对netty 程序进行分析,看看Netty模型特点
(1)添加 Netty 的依赖:
① 在模块中添加依赖库
② 如果没有的话,选择从Maven中新建依赖库:
③ 填写下载地址,并且下载 sources 和 javadocs,会把相关的包保存在当前项目中 lib 文件夹
选择下载的版本,进行下载。
④ 选中依赖的 jar 包,生成依赖库:
在模块中添加需要的依赖库,至此完毕。
(2)服务器端
服务器端代码:
public class NettyServer {
public static void main(String[] args) throws Exception{
//创建BossGroup 和 WorkerGroup
//说明
//1. 创建两个线程组 bossGroup 和 workerGroup
//2. bossGroup 只是处理连接请求 , 真正的和客户端业务处理,会交给 workerGroup完成
//3. 两个都是无限循环
//4. bossGroup 和 workerGroup 含有的子线程(NioEventLoop)的个数,可以通过构造器中看到
// 默认实际 cpu核数 * 2
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 设置处理器
// 给我们的workerGroup 的 EventLoop 对应的管道设置处理器
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new NettyServerHandler());
}
});
System.out.println(".....服务器 is ready...");
//绑定一个端口并且同步, 生成了一个 ChannelFuture 对象
//启动服务器(并绑定端口)
ChannelFuture cf = bootstrap.bind(6668).sync();
//对关闭通道进行监听
cf.channel().closeFuture().sync();
} finally {
//优雅关闭
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
服务器端Handler处理器:
/*
说明
1. 我们自定义一个Handler 需要继承netty 规定好的某个HandlerAdapter(规范)
2. 这时我们自定义一个Handler , 才能称为一个handler
*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
//读取数据实际(这里我们可以读取客户端发送的消息)
/*
1. ChannelHandlerContext ctx:上下文对象, 含有 管道pipeline , 通道channel, 地址
2. Object msg: 就是客户端发送的数据 默认Object
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
System.out.println("服务器读取线程 " + Thread.currentThread().getName());
System.out.println("server ctx =" + ctx);
System.out.println("看看channel 和 pipeline的关系");
Channel channel = ctx.channel();
ChannelPipeline pipeline = ctx.pipeline(); //pipeline 本质是一个双向链表, 出站入站
//将 msg 转成一个 ByteBuf
//ByteBuf 是 Netty 提供的,不是 NIO 的 ByteBuffer.
ByteBuf byteBuf = (ByteBuf) msg;
System.out.println("客户端发送消息是:" + byteBuf.toString(CharsetUtil.UTF_8));
System.out.println("客户端地址:" + ctx.channel().remoteAddress());
}
//数据读取完毕
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
//writeAndFlush 是 write + flush
//将数据写入到缓存,并刷新
//一般讲,我们对这个发送的数据进行编码
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵", CharsetUtil.UTF_8));
}
//处理异常, 一般是需要关闭通道
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
}
}
(3)客户端
客户端程序
public class NettyClient {
public static void main(String[] args) throws Exception{
//客户端需要一个事件循环组
EventLoopGroup group = new NioEventLoopGroup();
try {
//创建客户端启动对象
//注意客户端使用的不是 ServerBootstrap 而是 Bootstrap
Bootstrap bootstrap = new Bootstrap();
//设置相关参数
bootstrap.group(group) //设置线程组
.channel(NioSocketChannel.class) // 设置客户端通道的实现类(反射)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
//加入自己的处理器
ch.pipeline().addLast(new NettyClientHandler());
}
});
System.out.println("客户端 ok..");
//启动客户端去连接服务器端
//关于 ChannelFuture 要分析,涉及到netty的异步模型
ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6668).sync();
//给关闭通道进行监听
channelFuture.channel().closeFuture().sync();
} finally {
group.shutdownGracefully();
}
}
}
客户端Handler处理器:
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
//当通道就绪就会触发该方法
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("client:" + ctx);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, server: (>^ω^<)喵", CharsetUtil.UTF_8));
}
//当通道有读取事件时,会触发
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf byteBuf = (ByteBuf) msg;
System.out.println("服务器回复的消息:" + byteBuf.toString(CharsetUtil.UTF_8));
System.out.println("服务器的地址: "+ ctx.channel().remoteAddress());
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}
(4)分析程序
① BossGroup 和 WorkerGroup 如何确定下面有多少个子线程的?
bossGroup 和 workerGroup 含有的子线程(NioEventLoop)的个数,可以通过构造器中看到,默认实际 cpu核数 * 2
通过跟踪构造器方法,追踪到这里
如果没有指定线程数,就会使用 DEFAULT_EVENT_LOOP_THREADS
。
可以看到,一个
NioEventLoopGroup
如果没有指定线程数,默认的子线程数量= CPU 核数 * 2;
通过 Debug 可以看到一个 NIOEventLoopGroup 中会有8个 NioEventLoop ,而且它们的类型是 EventExecutor 类型的。
每个
NioEventLoop
都包含了自己的 selector,taskQueue,executor 等信息。
② 分别为 BossGroup 和 WorkerGroup 指定子线程数量为1个和8个,如果此时有8个客户端来通信, WorkerGroup 是怎么来分配8个 NioEventLoop?
经过测试,WorkerGroup 会依次为客户端分配一个线程,如果分配完毕了,就会从1号线程开始分配,采用轮询的方式。
③ ChannelHandlerContext 里面包含了什么,Channel 和 PipeLine 的关系是什么?
ChannelHandlerContext
里面包含了 handler、next和prev、inbound 表示入栈、pipeline 等很多信息,是一个重量级对象。
Channel 中包含了 selectionkey,pipeline 以及 eventLoop 等信息。
Pipeline 是一个双向链表,同时里面包含了 Channel 等信息。
Channel 和 Pipeline 是互相包含的一种关系。
五、任务队列
在整个事件循环(NioEventLoop)的过程中,在 pipeline 中会有一系列的 handler 进行业务处理,如果某个 Handler 里面有长时间操作,pipeline 就会有阻塞,因此,对于某些耗时任务,我们可以把这些任务提交到它对应的任务队列中去异步执行。
原来的任务:
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//比如这里我们有一个非常耗时长的业务-> 异步执行 -> 提交该channel 对应的 NIOEventLoop 的 taskQueue中
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵2", CharsetUtil.UTF_8));
}
这种情况会造成阻塞,可以把耗时较长的任务提交到对应的任务队列中,任务队列和 channle 是有一个对应的关系的。
1、用户程序自定义的普通任务
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//比如这里我们有一个非常耗时长的业务-> 异步执行 -> 提交该channel 对应的 NIOEventLoop 的 taskQueue中
//解决方案1 用户程序自定义的普通任务
ctx.channel().eventLoop().execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵2", CharsetUtil.UTF_8));
System.out.println("channel code=" + ctx.channel().hashCode());
} catch (Exception ex) {
System.out.println("发生异常" + ex.getMessage());
}
}
});
ctx.channel().eventLoop().execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵3", CharsetUtil.UTF_8));
System.out.println("channel code=" + ctx.channel().hashCode());
} catch (Exception ex) {
System.out.println("发生异常" + ex.getMessage());
}
}
});
}
可以看到我们添加到任务队列中的任务:
注意:这个任务队列是使用同一个线程来执行的,第一个任务执行完毕后再执行第二个任务。
2、用户自定义定时任务
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//比如这里我们有一个非常耗时长的业务-> 异步执行 -> 提交该channel 对应的 NIOEventLoop 的 taskQueue中
//解决方案1 用户程序自定义的普通任务
ctx.channel().eventLoop().execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵2", CharsetUtil.UTF_8));
System.out.println("channel code=" + ctx.channel().hashCode());
} catch (Exception ex) {
System.out.println("发生异常" + ex.getMessage());
}
}
});
ctx.channel().eventLoop().execute(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵3", CharsetUtil.UTF_8));
System.out.println("channel code=" + ctx.channel().hashCode());
} catch (Exception ex) {
System.out.println("发生异常" + ex.getMessage());
}
}
});
//解决方案2 : 用户自定义定时任务 -》 该任务是提交到 scheduleTaskQueue中
ctx.channel().eventLoop().schedule(new Runnable() {
@Override
public void run() {
try {
Thread.sleep(5 * 1000);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello, 客户端~(>^ω^<)喵4", CharsetUtil.UTF_8));
System.out.println("channel code=" + ctx.channel().hashCode());
} catch (Exception ex) {
System.out.println("发生异常" + ex.getMessage());
}
}
}, 5, TimeUnit.SECONDS);
}
注意:定时任务是提交到 scheduleTaskQueue中。
3、非当前 Reactor 线程调用 Channel 的各种方法
例如在推送系统的业务线程里面,根据用户的标识,找到对应的 Channel 引用,然后调用 Write 类方法向该用户推送消息,就会进入到这种场景。最终的 Write 会提交到任务队列中后被异步消费。
六、小结
(1)Netty 抽象出两组线程池, BossGroup 专门负责接收客户端连接, WorkerGroup 专门负责网络读写操作。
(2)NioEventLoop 表示一个不断循环执行处理任务的线程, 每个 NioEventLoop 都有一个 selector, 用于监听绑定在其上的 socket 网络通道。
(3)NioEventLoop 内部采用串行化设计, 从消息的读取->解码->处理->编码->发送, 始终由 IO 线程 NioEventLoop 负责
- NioEventLoopGroup 下包含多个 NioEventLoop
- 每个 NioEventLoop 中包含有一个 Selector, 一个 taskQueue
- 每个 NioEventLoop 的 Selector 上可以注册监听多个 NioChannel
- 每个 NioChannel 只会绑定在唯一的 NioEventLoop 上
- 每个 NioChannel 都绑定有一个自己的 ChannelPipeline
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】凌霞软件回馈社区,博客园 & 1Panel & Halo 联合会员上线
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】博客园社区专享云产品让利特惠,阿里云新客6.5折上折
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· 微软正式发布.NET 10 Preview 1:开启下一代开发框架新篇章
· DeepSeek R1 简明指南:架构、训练、本地部署及硬件要求
· 没有源码,如何修改代码逻辑?
· NetPad:一个.NET开源、跨平台的C#编辑器
· 面试官:你是如何进行SQL调优的?
2021-03-21 Java枚举类(Enum)