NIO框架

最新推荐文章于 2023-06-20 05:45:50 发布

逗逗大魔王

最新推荐文章于 2023-06-20 05:45:50 发布

阅读量927

点赞数

分类专栏： java

本文链接：https://blog.csdn.net/qq_38682952/article/details/96479303

版权

java 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

一、简介

流行基于Java NIO通信框架有Mina、Netty、Grizzly等。

1、Mina

来自于开源界的大牛Apache组织，是 Apache 组织一个较新的项目，它为开发高性能和高可用性的网络应用程序提供了非常便利的框架，支持基于 Java NIO 技术的 TCP/UDP 应用程序开发、串口通讯程序。

2、Netty

来自于商业开源大亨Jboss，是一款异步的事件驱动的网络应用框架和工具，用于快速开发可维护的高性能、高扩展性协议服务器和客户端。也就是说，Netty是一个NIO客户端/服务器框架，支持快速、简单地开发网络应用。基于JAVA NIO提供的API实现。它提供了对TCP、UDP和文件传输的支持，作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。

3、Grizzly

来自于Sun公司，是一种应用程序框架，专门解决编写成千上万用户访问服务器时候产生的各种问题。使用JAVA NIO作为基础，并隐藏其编程的复杂性。容易使用的高性能的API。带来非阻塞socketd到协议处理层。利用高性能的缓冲和缓冲管理使用高性能的线程池。

总结：几乎都是对于NIO的简单封装，但是Netty框架API使用简单，开发门槛低，它的健壮性、功能、性能、可定制性和可扩展性在同类框架都是首屈一指的，作为当前最流行的NIO框架，Netty框架的目标就是让你的业务逻辑从网络基础应用编码中分离出来、解脱出来，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，一些业界著名的开源组件也基于Netty的NIO框架构建如：dubbo，RocketMQ，Hadoop，mycat，Spring5等。

二、线程模型

了解Netty框架的线程模型之前先明白Reactor模式，也就是IO模型中的多路复用模型。Netty其实本质上就是Reactor模式的实现，Selector作为多路复用器，EventLoop作为转发器，Pipeline作为事件处理器。但是和一般的Reactor不同的是，Netty使用串行化实现，并在Pipeline中使用了责任链模式。Netty中的buffer相对有NIO中的buffer又做了一些优化，大大提高了性能

Reactor 模式，是指通过一个或多个输入同时传递给服务处理器的服务请求的事件驱动处理模式。服务端程序处理传入多路请求，并将它们同步分派给请求对应的处理线程，Reactor模式也叫 Dispatcher 模式。

Reactor：Reactor 在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对 IO 事件做出反应。
Handlers：处理程序执行 I/O 事件要完成的实际事件，Reactor 通过调度适当的处理程序来响应 I/O 事件，处理程序执行非阻塞操作。

1、Reactor单线程模型

所有的IO操作都在同一个NIO线程上面完成，接收客户端的TCP连接，向服务端发起TCP连接，读取通信对端的请求或者应答消息，向通信对端发送消息请求或者应答消息。Reactor 对象通过 Select 监控客户端请求事件，收到事件后通过 Dispatch 进行分发；如果是建立连接请求事件，则由 Acceptor 通过 Accept 处理连接请求，然后创建一个 Handler 对象处理连接完成后的后续业务处理；如果不是建立连接事件，则 Reactor 会分发调用连接对应的 Handler 来响应，Handler 会完成 Read→业务处理→Send 的完整业务流程。

但是对于高负载、大并发的应用，一个NIO线程同时处理成百上千的链路，性能上无法支撑，当NIO线程负载过重之后，处理速度将变慢，这会导致大量客户端连接超时，一旦NIO线程意外跑飞，或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障

2、Reactor多线程模型

有专门一个NIO线程-Acceptor线程用于监听服务端，接收客户端的TCP连接请求，网络IO操作-读、写等由一个NIO线程池负责，它包含一个任务队列和N个可用的线程，由这些NIO线程负责消息的读取、解码、编码和发送。Reactor 对象通过 Select 监控客户端请求事件，收到事件后通过 Dispatch 进行分发；如果是建立连接请求事件，则由 Acceptor 通过 Accept 处理连接请求，然后创建一个 Handler 对象处理连接完成后续的各种事件；如果不是建立连接事件，则 Reactor 会分发调用连接对应的 Handler 来响应；Handler 只负责响应事件，不做具体业务处理，通过 Read 读取数据后，会分发给后面的 Worker 线程池进行业务处理；Worker 线程池会分配独立的线程完成真正的业务处理，如何将响应结果发给 Handler 进行处理；Handler 收到响应结果后通过 Send 将响应结果返回给 Client。

一个NIO线程负责监听和处理所有的客户端连接可能会存在性能问题，对于并发百万客户端连接，或者服务端需要对客户端握手进行安全认证，但是认证本身非常损耗性能。在这类场景下，单独一个Acceptor线程可能会存在性能不足问题

3、主从多线程模型

服务端用于接收客户端连接的不再是个1个单独的NIO线程，而是一个独立的NIO线程池。Acceptor接收到客户端TCP连接请求处理完成后（可能包含接入认证等），将新创建的SocketChannel注册到IO线程池（sub reactor线程池）的某个IO线程上，由它负责SocketChannel的读写和编解码工作。Acceptor线程池仅仅只用于客户端的登陆、握手和安全认证，一旦链路建立成功，就将链路注册到后端subReactor线程池的IO线程上，由IO线程负责后续的IO操作。Reactor 主线程 MainReactor 对象通过 Select 监控建立连接事件，收到事件后通过 Acceptor 接收，处理建立连接事件；Acceptor 处理建立连接事件后，MainReactor 将连接分配 Reactor 子线程给 SubReactor 进行处理；SubReactor 将连接加入连接队列进行监听，并创建一个 Handler 用于处理各种连接事件；当有新的事件发生时，SubReactor 会调用连接对应的 Handler 进行响应；Handler 通过 Read 读取数据后，会分发给后面的 Worker 线程池进行业务处理；Worker 线程池会分配独立的线程完成真正的业务处理，如何将响应结果发给 Handler 进行处理；Handler 收到响应结果后通过 Send 将响应结果返回给 Client。

父线程与子线程的数据交互简单职责明确，父线程只需要接收新连接，子线程完成后续的业务处理。父线程与子线程的数据交互简单，Reactor 主线程只需要把新连接传给子线程，子线程无需返回数据。这种模型在许多项目中广泛使用。

三、Netty组件

1、引导类

Netty 的引导类为应用程序的网络层配置提供了容器，这涉及将一个进程绑定到某个指定的端口，或者将一个进程连接到另一个运行在某个指定主机的指定端口上的进程用于客户端(Bootstrap)，用于服务器(ServerBootstrap)。ServerBootstrap绑定到指定端口来监听客户端连接请求，Bootstrap连接至远程服务端。

 ServerBootstrap bootstrap = new ServerBootstrap();//服务端
 Bootstrap b = new Bootstrap();//客户端

2、EventLoopGroup

ServerBootstrap包含两个EventLoopGroup，而Bootstrap只包含一个EventLoopGroup。服务端BossGroup 专门负责接收客户端连接，WorkerGroup 专门负责网络读写操作。ServerBootstrap包含两组通道，第一组包含一个ServerChannel，表示服务器绑定到本地端口的监听套接字；第二组包含用来处理客户端连接所创建的所有通道，每接受一个连接时便会创建一个通道，EventLoopGroup为关联的ServerChannel分配一个EventLoop，其为连接请求创建通道,一旦一个连接请求被接受时，第二个EventLoopGroup将为通道创建EventLoop。对于服务端也可以只用一个线程池，但仅由一个EventLoopGroup处理所有请求和连接的话，在并发量很大的情况下，这个EventLoopGroup有可能会忙于处理已经接收到的连接而不能及时处理新的连接请求，用两个的话，会有专门的线程来处理连接请求，不会导致请求超时的情况，大大提高了并发处理能力。

3、EventLoop

EventLoop是Netty的Reactor线程，用于接收和连接的线程，IO操作读写到Channel的线程。一个 EventLoopGroup 包含一个或多个 EventLoop，一个 EventLoop 在它的生命周期内只能与一个Thread绑定，所有有 EnventLoop 处理的 I/O 事件都将在它专有的 Thread 上被处理，EventLoop 中包含有一个 Selector，一个 taskQueue，每个EventLoop 的 Selector 上可以注册监听多个Channel。当一个连接到达时，Netty 就会注册一个 Channel，然后从 EventLoopGroup 中分配一个 EventLoop 绑定到这个Channel上，在该Channel的整个生命周期中都是有这个绑定的 EventLoop 来服务的

4、Channel

Channel 是 Netty 网络操作抽象类，它除了包括基本的 I/O 操作，如 bind、connect、read、write 之外，还包括了 Netty 框架相关的一些功能，如获取该 Channe l的 EventLoop。

NioSocketChannel，异步的客户端 TCP Socket 连接。NioServerSocketChannel，异步的服务器端 TCP Socket 连接。NioDatagramChannel，异步的 UDP 连接。NioSctpChannel，异步的客户端 Sctp 连接。NioSctpServerChannel，异步的 Sctp 服务器端连接，这些通道涵盖了 UDP 和 TCP 网络 IO 以及文件 IO。

5、ChannelFuture

Netty 为异步非阻塞，即所有的 I/O 操作都为异步的，因此，我们不能立刻得知消息是否已经被处理了。Netty 提供了 ChannelFuture 接口，通过该接口的 addListener() 方法注册一个 ChannelFutureListener，当操作执行成功或者失败时，监听就会自动触发返回结果，可以获取操作执行的状态，注册监听函数来执行完成后的操作，得知消息是否被正确处理。当做了一个I/O操作并有任何后续任务的时候，推荐优先使用addListener(GenericFutureListener)的方式来获得通知，而非await()，addListener是非阻塞的。它会把特定的ChannelFutureListener添加到ChannelFuture中，然后I/O线程会在I/O操作相关的future完成的时候通知监听器，await()是一个阻塞的操作。一旦被调用，调用者线程会阻塞，直到操作完成。

future.addListener(new MyFuture() {
				@Override
				public boolean isCancelled() {
					return false;
				}
				@Override
				public boolean isDone() {
					return false;
				}
				@Override
				public boolean isSuccess() {
					return false;
				}
				@Override
				public boolean isCancellable() {
					return false;
				}
			});

6、ChannelHandler

它充当了所有处理入站和出站数据的应用程序逻辑的容器，主要用来处理各种事件，这里的事件很广泛，比如可以是连接、数据接收、异常、数据转换等，有ChannelHandlerAdapter，ChannelInboundHandlerAdapter，ChannelOutboundHandlerAdapter ChannelDuplexHandler等。ChannelInboundHandler用于处理入站 I/O 事件，如：从客户端发往服务器的报文进行处理，一般用来执行半包/粘包，解码，读取数据，业务处理等；ChannelOutboundHandler用于处理出站 I/O 操作，如：从服务器发往客户端的报文进行处理，一般用来进行编码，发送报文到客户端。

7、ChannelPipeline

ChannelPipeline实现了一种高级形式的拦截过滤器模式，担任着Reactor模式中的请求处理器这个角色，主要是为了方便事件的拦截和用户业务逻辑的定制，ChannelPipeline 中维护了由 ChannelHandlerContext 组成的双向链表，ChannelHandlerContext 中又关联着一个 ChannelHandler，也就是说ChannelPipeline是ChannelHandler的容器，它负责ChannelHandler的管理和事件拦截与调度。用户不需要自己创建pipeline，因为使用ServerBootstrap或者Bootstrap启动服务端或者客户端时，Netty会为每个Channel连接创建一个独立的pipeline。对于使用者而言，只需要将自定义的拦截器加入到pipeline中即可。

pipeline = ch.pipeline();
pipeline.addLast("decoder", new StringDecoder());
pipeline.addLast("encoder", new StringEncoder());

8、Buffer

Netty提供的经过扩展的Buffer相对NIO中的有个许多优势，作为数据存取非常重要的一块。采用了读写指针分别为readerIndex和writerIndex，相对于NIO中的buffer每次读之前调用flip，写之前调用clear，这样无疑给开发带来了繁琐的步骤，而且内容没有读完是不能写的，这样非常不灵活。而Netty框架中的ByteBuf，读的时候仅仅依赖readerIndex指针，写的时候仅仅依赖writerIndex指针，不需每次读写之前调用对应的方法，而且没有必须一次读完的限制。

Netty的接收和发送ByteBuffer使用堆外直接内存进行Socket读写，不需要进行字节缓冲区的二次拷贝，Netty的文件传输采用了transferTo方法，它可以直接将文件缓冲区的数据发送到目标Channel，避免了传统通过循环write方式导致的内存拷贝问题。

每个被申请的Buffer对于Netty来说都可能是很宝贵的资源，因此为了获得对于内存的申请与回收更多的控制权，Netty自己根据引用计数法去实现了内存的管理，Netty结合引用计数实现了PolledBuffer，即池化的用法，当引用计数等于0的时候，Netty将Buffer回收致池中，在下一次申请Buffer的某个时刻会被复用。

四、Netty流程

启动过程：

//服务端
-> AbstractBootstrap.bind(port)
-> AbstractBootstrap.bind(address) 
-> AbstractBootstrap.doBind(final SocketAddress localAddress) 
-> AbstractBootstrap.initAndRegister 
-> AbstractBootstrap.doBind0

//客户端
-> Bootstrap.doResolveAndConnect
-> AbstractBootstrap.initAndRegister 
-> Bootstrap.doResolveAndConnect0
-> Bootstrap.doConnect

//后续初始化操作
-> SingleThreadEventExecutor.execute 
-> SingleThreadEventExecutor.startThread()
-> SingleThreadEventExecutor.doStartThread

Bootstrap启动时，AbstractUnsafe.register这个方法，在这里初始化了一个EventLoop，然后把EventLoop进行分配给channel，Channel.register注册到EventLoop，当有任务来时，线程池会把它提交给EventLoop，执行EventLoop的execute方法，里面执行startThread方法，然后又会执行doStartThread，而线程初始化操作由这个方法执行，线程池会调用doStartThread方法进行初始化，NioEventLoop在一个无限循环里面，只有在遇到shutdown的情况下才会停止循环。然后在循环里会询问是否有事件，如果没有，则继续循环，如果有事件，那么就开始处理时间，在循环中EventLoop会处理IO事件和非IO事件。

IO 任务，即 selectionKey 中 ready 的事件，如 accept、connect、read、write 等，由 processSelectedKeys 方法触发；非 IO 任务，添加到 taskQueue 中的任务，如 register0、bind0 等任务，由 runAllTasks 方法触发，两种任务的执行时间比由变量 ioRatio 控制，默认为 50，则表示允许非 IO 任务执行的时间与 IO 任务的执行时间相等。

里面通过processSelectedKeys方法来进行IO操作，而非I/O操作通过runAllTasks反复来进行，处理IO事件中具体执行processSelectedKey方法，从Channel上获取一个unsafe对象，这个对象是用来进行NIO操作的一系列系统级API，从Channel上获取了eventLoop，根据事件调用底层API来处理事件。

线程EventLoop调用run方法执行任务，首先看任务队列中是否有超时的定时任务和普通任务，如果有则按照比例循环执行这些任务，如果没有需要理解执行的任务，则调用Selector的select方法进行等待，从定时任务Task队列中弹出delay最小的Task，计算超时时间，等待的时间为定时任务队列中第一个超时的定时任务时延。一次循环的执行称之为tick，经过周期tick之后，扫描定时任务列表，将超时的定时任务移除到普通任务队列中，等待执行。检测和拷贝任务完成之后，就执行超时的定时任务调用runAllTasks方法，为了保证定时任务的执行不会因为过度挤占IO事件的处理，Netty提供了IO执行比例供用户设置，用户可以设置分配给IO的执行比例，防止因为海量定时任务的执行导致IO处理超时或者积压，因为获取系统的纳秒时间是件耗时的操作，所以Netty每执行64个定时任务检测一次是否达到执行的上限时间，达到则退出。如果没有执行完，放到下次Selector轮询时再处理，给IO事件的处理提供机会。

服务端实现

public class NettyServer {

	public void run(int port) {
		EventLoopGroup bossGroup = new NioEventLoopGroup();
		EventLoopGroup workerGroup = new NioEventLoopGroup();

		ServerBootstrap bootstrap = new ServerBootstrap();
		bootstrap.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
				.childHandler(new ChannelInitializer<SocketChannel>() {
					@Override
					public void initChannel(SocketChannel ch) throws Exception {
						ch.pipeline().addLast("decoder", new StringDecoder());
						ch.pipeline().addLast("encoder", new StringEncoder());
						ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
							@Override
							public void channelRead(ChannelHandlerContext ctx, Object msg) {
								ctx.writeAndFlush(msg.toString() + "你好");
							}
							@Override
							public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
								cause.printStackTrace();
								ctx.close();
							}
						});
					}
				})
				.option(ChannelOption.SO_BACKLOG, 128)
				.childOption(ChannelOption.SO_KEEPALIVE, true);

		try {
			ChannelFuture f = bootstrap.bind(port).sync();
			f.channel().closeFuture().sync();
		} catch (InterruptedException e) {
			e.printStackTrace();
		} finally {
			workerGroup.shutdownGracefully();
			bossGroup.shutdownGracefully();
		}
	}
	public static void main(String[] args) {
		
	   new NettyServer().run(2222);
	}
}

客户端实现

public class NettyClient {

	private Channel channel;
	public Channel connect(String host, int port) {
		doConnect(host, port);
		return this.channel;
	}
	private void doConnect(String host, int port) {
		EventLoopGroup workerGroup = new NioEventLoopGroup();
		try {
			Bootstrap b = new Bootstrap();
			b.group(workerGroup);
			b.channel(NioSocketChannel.class);
			b.option(ChannelOption.SO_KEEPALIVE, true);
			b.handler(new ChannelInitializer<SocketChannel>() {
				@Override
				public void initChannel(SocketChannel ch) throws Exception {
					ch.pipeline().addLast("decoder", new StringDecoder());
					ch.pipeline().addLast("encoder", new StringEncoder());
					ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
						@Override
						public void channelRead(ChannelHandlerContext ctx, Object msg) {
							System.out.println("client:" + msg.toString());
						}

						@Override
						public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
							cause.printStackTrace();
							ctx.close();
						}
					});
				}
			});
			ChannelFuture f = b.connect(host, port).sync();
			channel = f.channel();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	public static void main(String[] args) {
		 Channel channel = new ImConnection().connect("127.0.0.1", 2222);
		 channel.writeAndFlush("wang");
	}
}

BossGroup专门负责接收客户端连接，WorkerGroup专门负责网络读写操作

NioEventLoop是Netty的Reactor线程，用于接收和连接的线程，IO操作读写到Channel的线程。

group()方法，添加NioEventLoopGroup线程组

channel()方法，会在两者之间建立Channel，这个方法就是为了指定建立什么类型的通道，从而实例化channel

handler()方法，指定的处理类是主线程池中对通道的处理类

childHandler()方法，用来配置具体的数据处理方式，可以指定编解码器，处理数据的Handler，事件可以是连接、数据接收、异常、数据转换

ChannelOption()方法，里面定义了netty参数，socket参数，ip参数，tcp参数，来表示各状态和类型

ChannelPipeline 担任着Reactor模式中的请求处理器这个角色

sync()方法，异步绑定服务器，调用sync方法阻塞等待直到绑定成功

closeFuture()方法，关闭Channel通道

shutdownGracefully()方法，完成关闭线程组

逗逗大魔王

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
NIO框架

一、简介流行基于Java NIO通信框架有Mina、Netty、Grizzly等。1、Mina来自于开源界的大牛Apache组织，是 Apache 组织一个较新的项目，它为开发高性能和高可用性的网络应用程序提供了非常便利的框架，支持基于 Java NIO 技术的 TCP/UDP 应用程序开发、串口通讯程序。2、Netty来自于商业开源大亨Jboss，是一款异步的事件驱动的网络应...
复制链接

扫一扫