Netty架构设计
Netty简介
- 一个异步的、基于事件驱动的网络应用框架,用以快速开发高性能、高可靠性的网路IO程序;
- 主要针对TCP协议下,面向clients端的高并发应用,或者大量数据传输的应用;
- 本质是一个NIO框架,适用于服务器通信相关的多种应用场景;
线程模型
名词解释 :
黄色的框表示对象, 蓝色的框表示线程,白色的框表示方法(API);
传统阻塞IO模型
特点:
- 采用阻塞IO模式获取输入的数据;
- 每个连接都需要独立的线程完成数据的输入、业务处理、数据返回等工作;
优缺点分析:
- 当并发数很大,就会创建大量的线程,占用很大系统资源;
- 连接创建后,如果当前线程暂时没有数据可读,该线程会阻塞在read,造成线程资源浪费;
Reactor模型
特点:
- 基于 I/O 复用模型:多个连接(Client)共用一个阻塞对象(ServiceHandler),应用程序只需要在一个阻塞对象等待,无需阻塞等待的所有连接。
- 当某个连接有新的数据可以处理时,操作系统通知应用程序,线程从阻塞状态返回,开始进行业务处理;
- 服务器端程序处理传入的多个请求,并将它们同步分派到相应的处理线程, 基于线程池复用线程原则,不必再为每个连接创建线程,将连接完成后的业务处理任务分配给线程进行处理,一个线程就可以复用处理多个连接的业务,因此Reactor模式也叫 Dispatcher模式;
- Reactor 模式使用IO复用监听事件, 收到事件后,分发给某个线程(进程), 这点就是网络服务器高并发处理关键;
- 响应快,不必为单个同步时间所阻塞,虽然 Reactor 本身依然是同步的,多个SubReactor有效的避免了阻塞;
- 可以最大程度的避免复杂的多线程及同步问题,并且避免了多线程/进程的切换开销;
- 扩展性好,可以方便的通过增加 Reactor 实例个数来充分利用 CPU 资源;
- 复用性好,Reactor 模型本身与具体事件处理逻辑无关,具有很高的复用性;
单Reactor单线程模型
- 上图Select可以实现应用程序通过一个阻塞对象监听多路连接请求;
- 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主线程 MainReactor 对象通过select 监听连接事件, 收到事件后,通过Acceptor 处理连接事件,Reactor 主线程可以对应多个Reactor 子线程, 即MainRecator 可以关联多个SubReactor;
- 当 Acceptor 处理连接事件后,MainReactor 将连接分配给SubReactor ;
- Subreactor 将连接加入到连接队列进行监听,并创建handler进行各种事件处理;
- 当有新事件发生时, subreactor 就会调用对应的handler处理;
- handler 通过read 读取数据,分发给后面的worker 线程处理;
- worker 线程池分配独立的worker 线程进行业务处理,并返回结果;
- handler 收到响应的结果后,再通过send 将结果返回给client;
优缺点:
- 父线程与子线程的数据交互简单职责明确,父线程只需要接收新连接,子线程完成后续的业务处理;
- 父线程与子线程的数据交互简单,Reactor 主线程只需要把新连接传给子线程,子线程无需返回数据;
- 编程复杂度较高;
Netty模型
- Netty抽象出两组线程池 BossGroup 专门负责接收客户端的连接, WorkerGroup 专门负责网络的读写;
- BossGroup 和 WorkerGroup 类型都是 NioEventLoopGroup;
- NioEventLoopGroup 相当于一个事件循环组, 这个组中含有多个事件循环 ,每一个事件循环是 NioEventLoop;
- NioEventLoop 表示一个不断循环的执行处理任务的线程, 每个NioEventLoop 都有一个selector , 用于监听绑定在其上的socket的网络通讯;
- NioEventLoopGroup 可以有多个线程, 即可以含有多个NioEventLoop;
- 每个Boss下的NioEventLoop 循环执行的步骤有3步:轮询accept 事件、处理accept 事件,与client建立连接,生成NioScocketChannel,并将其注册到某个worker中NIOEventLoop上的selector中、处理任务队列的任务 , 即 runAllTasks;
- 每个 Worker下的NIOEventLoop 循环执行的步骤:轮询read,write 事件、处理i/o事件,即read , write 事件,在对应NioScocketChannel 处理、处理任务队列的任务 , 即 runAllTasks;
- 每个Worker下的NIOEventLoop 处理业务时,会使用pipeline(管道), pipeline 中包含了 channel , 即通过pipeline 可以获取到对应通道, 管道中维护了很多的 处理器;
- Worker下的NIOEventLoop 处理业务采用轮询机制;
Netty-Demo
服务器端:
package com.neei.netty.simple;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
/**
* @param
* @Author: AaNeei
* @Date: 2019/12/4 22:24
* @Description: 游学网
* @throws:
*/
public class NettyServer {
public static void main(String[] args) throws InterruptedException {
//创建BossGroup线程组
EventLoopGroup bossGroup = new NioEventLoopGroup();
//创建WorkerGroup线程组
EventLoopGroup workerGroup = new NioEventLoopGroup();
//创建服务器端启动对象
ServerBootstrap bootstrap = new ServerBootstrap();
try {
//设置参数
bootstrap.group(bossGroup, workerGroup)//绑定线程组
.channel(NioServerSocketChannel.class)//使用NioServerSocketChannel作为服务器的通道
.option(ChannelOption.SO_BACKLOG, 128)//设置线程队列连接数
.childOption(ChannelOption.SO_KEEPALIVE, true)//设置保持活动连接状态
.childHandler(new ChannelInitializer<SocketChannel>() {
//为pipeline设置处理器
@Override
protected void initChannel(SocketChannel socketChannel) throws Exception {
//注册处理器handler
socketChannel.pipeline().addLast(new NettyServerHandler());
}
});//设置WorkerGroup的 EventLoop 对应的管道设置处理器
//服务准备完毕
System.out.println("------------- NettyServer is ready --------------");
//绑定端口并同步,启动服务
ChannelFuture channelFuture = bootstrap.bind(6666).sync();
//监听关闭的通道
channelFuture.channel().closeFuture().sync();
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
}
服务器Handler:
package com.neei.netty.simple;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
/**
* @param
* @Author: AaNeei
* @Date: 2019/12/5 22:13
* @Description: 游学网
* @throws:
*/
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
/**
* 读取数据方法
* 当通道有读取事件时触发该方法
* @param ctx 上下文对象 包含:pipeline、channel等
* @param msg 数据内容
* @throws Exception
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
//如果存在耗时操作,需要将其放到task队列中去异步执行
//1.自定义线程
ctx.channel().eventLoop().execute(() -> {
try {
Thread.sleep(10000L);
ctx.writeAndFlush(Unpooled.copiedBuffer("这是耗时操作", CharsetUtil.UTF_8));
} catch (InterruptedException e) {
e.printStackTrace();
}
});
//2.定时执行
ctx.channel().eventLoop().schedule(() -> {
ctx.writeAndFlush(Unpooled.copiedBuffer("这是定时执行操作", CharsetUtil.UTF_8));
}, 5, TimeUnit.SECONDS);
System.out.println("server ctx=" + ctx);
ByteBuf buf = (ByteBuf) msg;
System.out.println("客户端发送的消息是:" + buf.toString(CharsetUtil.UTF_8));
System.out.println("客户端地址:" + ctx.channel().localAddress());
}
/**
* 读取数据完成之后 触发该方法
* 可以执行的操作
*/
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.writeAndFlush(Unpooled.copiedBuffer("hello,NettyClient", CharsetUtil.UTF_8));
}
/**
* 异常触发该方法
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
super.exceptionCaught(ctx, cause);
}
}
客户端
package com.neei.netty.simple;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
/**
* @param
* @Author: AaNeei
* @Date: 2019/12/5 22:29
* @Description: 游学网
* @throws:
*/
public class NettyClient {
public static void main(String[] args) throws InterruptedException {
EventLoopGroup eventLoopGroup = new NioEventLoopGroup();
Bootstrap bootstrap = new Bootstrap();
try {
bootstrap.group(eventLoopGroup)
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new NettyClientHandler());
}
});
System.out.println("----------client is ok---------");
ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 6666).sync();
channelFuture.channel().closeFuture().sync();
} finally {
eventLoopGroup.shutdownGracefully();
}
}
}
客户端handler:
package com.neei.netty.simple;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.CharsetUtil;
/**
* @param
* @Author: AaNeei
* @Date: 2019/12/5 22:37
* @Description: 游学网
* @throws:
*/
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
/**
* 通道就绪触发该方法
*
* @param ctx
* @throws Exception
*/
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
System.out.println("Client ctx=" + ctx);
ctx.writeAndFlush(Unpooled.copiedBuffer("hello,NettyServer", CharsetUtil.UTF_8));
}
/**
* 通道有读事件时触发该方法
*
* @param ctx
* @param msg
* @throws Exception
*/
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
ByteBuf buf = (ByteBuf) msg;
System.out.println("服务器回复消息:" + buf.toString(CharsetUtil.UTF_8));
System.out.println("服务器地址:" + ctx.channel().localAddress());
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
ctx.close();
cause.printStackTrace();
}
}
注:学习资源连接谷粒学院