NIO&Netty

最新推荐文章于 2024-07-20 23:59:39 发布

超人@不会飞

最新推荐文章于 2024-07-20 23:59:39 发布

阅读量97

点赞数

分类专栏：分布式文章标签： java

本文链接：https://blog.csdn.net/weixin_39515823/article/details/119148526

版权

分布式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

一、IO模型

1. I/O模型说明

IO模型就是用什么样的通道进行数据的发送给和接收，很大程度上决定了程序通信的性能。

Java共支持3种网络编程模型：BIO(同步并阻塞)、NIO(同步非阻塞)、AIO(异步非阻塞)

1.1 BIO 同步并阻塞

Java BIO就是传统的socket编程。

BIO ：同步并阻塞，服务器实现模式是一个链接一个线程，即客户端有连接请求时服务器就启动一个线程进行处理，如果这个线程不做任何事情就会造成不必要的线程开销。

在这里插入图片描述

BIO 问题分析

每个请求都要创建新的线程，来处理客户端的连接和数据的读写
并发较大时，要创建大量的线程来处理连接，系统资源占用大
连接建立后，当线程上没有可操作的数据，线程就阻塞等待，造成线程资源的浪费。

1.2 NIO 同步非阻塞

同步非阻塞。服务器实现模式是一个线程处理多个链接（请求）,即客户端发送连接都会注册到多路复用器上，多路复用器轮询到连接有I/O请求就进行处理。

在这里插入图片描述

1.3 AIO 异步非阻塞

AIO引入异步通道的概念，采用Proactor模式，服务器实现模式是一个有效请求一个线程。它的特点是先有操作系统完成后才通知服务端启动线程去处理。

Proactor模式是一个消息异步通知的设计模式，Proactor通知的不是就绪事件，而是操作完成事件，这也就是操作系统异步io的主要模型。

1.4 BIO、NIO、AIO使用场景分析

BIO适用与连接数较小且固定的框架。这种方式对服务器支援要求较高，并发局限于应用中。JDK1.4以前的唯一选择，但程序简单易理解。
NIO：适用与连接数较多且连接比较短（轻操作）的框架。比如：聊天服务器，弹幕系统，服务器间通讯等。编程比较复杂，JDK１.４开始支持。
AIO：适用与连接数较多且连接比较长（重操作）的框架。比如：相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

2. NIO

2.1 介绍

NIO的相关类都放在java.nio包及其子包下，并且对原java.io包中的很多类进行改写。
NIO有三个核心部分：Channel（通道），Buffer（缓冲区），Selector（选择器）
Java NIO的非阻塞模式，使一个线程从某通道发送请求或读取数据，但是它进能够得到前可用的数据，如果目前没有数据可用时，就什么也不会获取，而不是保持线程阻塞，所以直至数据变得可以读取之前，该线程可以继续做其他事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但部需要等待它完全写入，这个线程同事可以去做别的事情。

2.2 NIO和BIO的比较

BIO以流的方式处理数据，而NIO以缓存区的方式处理数据，缓冲区的方式比流的方式效率高的多
BIO是阻塞的，NIO是非阻塞的
BIO基于字节流和字符流进行操作，而NIO基于Channel（通道）和Buffer（缓冲区）进行操作，数据总是从通道读取到缓冲区，或者从缓冲区写入到通道中。Selector（选择器）用于监听多个通道的事件（比如：连接请求，数据到达等），因此使单个线程可以监听多个客户端通道

2.3 NIO三大核心原理示意图

NIO有三大核心部分：Channel（通道）、Buffer（缓冲区）和Selector（选择器）

Channel通道

Java NIO的通道和流类似，但又有些不同：既可以从通道中读取数据，又可以向通道中写入数据。通道是双向的。但流（input/output）读写通常是单向的。

Selector选择器

Selector是Java NIO组件，可以检查一个或多个NIO通道，并确定哪些通道已经准备好进行读取或写入数据。这样一个单独的线程可以管理多个channel，从而管理多个网络连接，提供效率。

在这里插入图片描述

每个Channel都对应一个Buffer
一个线程对应一个Selector，一个Selector 对应多个Channel（连接）
程序切换到哪个Channel是由事件决定的
Selector会根据不同的事情在各个通道上切换
Buffer就是一个内存，底层是一个数组
数据的读取写入是通过Buffer完成的，BIO中要么是输入流，或者是输出流，不能是双向的，但是NIO的Buffer是可以读也可以写。
Java NIO系统的核心在于：通道（Channel）和缓冲区（Buffer）。通道表示打开到IO设备（例如：文件、套接字）的连接。若需要使用NIO系统，需要获取用于连接IO设备的通道已经用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。简言之，Channel负责传输，Buffer负责存取数据。

2.4 Buffer缓冲区

2.4.1 基本介绍

缓冲区本质上是一块内存，能进行数据的写入和读取。这块内存被包装成NIO的Buffer对象，并提供过了一组方法，用来访问该块内存。相比较直接对数组的操作，Buffer API更加容易操作和管理。缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化。Channel提供从网络读取数据的渠道，但是读取数据或写入数据必须经由Buffer。

在这里插入图片描述

2.4.2 Buffer常用API介绍

Buffer类及其子类

在这里插入图片描述

在NIO中，Buffer是一个顶层父类，它是一个抽象类，类的层级关系图。常用的缓冲区分别对应byte,short,int,long,float,double,char7种。

缓冲区对象的创建

方法名说明
static XxxBuffer allocate(int capacity) 创建xxx类型的指定长度的缓冲区
static XxxBuffer wrap(byte[] array) 创建一个有内容的xxx类型缓冲区

方法名	说明
static XxxBuffer allocate(int capacity)	创建xxx类型的指定长度的缓冲区
static XxxBuffer wrap(byte[] array)	创建一个有内容的xxx类型缓冲区

缓冲区的基本属性

属性	说明
capacity(容量)	作为一个内存块，Buffer具有一定的固定大小，也称为"容量"，缓冲区容量不能为负，并且创建后不能更改。
limit(限制)	表示缓冲区中可以操作数据的大小（limit 后数据不能进行读写）。缓冲区的限制不能为负，并且不能大于其容量。写入模式，限制等于buffer的容量。读取模式下，limit等于写入的数据量
position(位置)	下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制
mark(标记)	标记是一个索引，通过 Buffer 中的 mark() 方法指定 Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这个 position。标记、位置、限制、容量遵守以下不变式： 0 <= mark <= position <= limit <= capacity

在这里插入图片描述

Buffer常见方法

Buffer clear() 清空缓冲区并返回对缓冲区的引用
Buffer flip() 为 将缓冲区的界限设置为当前位置，并将当前位置充值为 0
int capacity() 返回 Buffer 的 capacity 大小
boolean hasRemaining() 判断缓冲区中是否还有元素
int limit() 返回 Buffer 的界限(limit) 的位置
Buffer limit(int n) 将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象
Buffer mark() 对缓冲区设置标记
int position() 返回缓冲区的当前位置 position
Buffer position(int n) 将设置缓冲区的当前位置为 n , 并返回修改后的 Buffer 对象
int remaining() 返回 position 和 limit 之间的元素个数
Buffer reset() 将位置 position 转到以前设置的 mark 所在的位置
Buffer rewind() 将位置设为为 0， 取消设置的mark，可以重复读

缓冲区的数据操作

Buffer所有子类提供了两个用于数据操作的方法：get() put() 方法
取获取 Buffer中的数据
get() ：读取单个字节
get(byte[] dst)：批量读取多个字节到 dst 中
get(int index)：读取指定索引位置的字节(不会移动 position)
    
放到 入数据到 Buffer 中 
put(byte b)：将给定单个字节写入缓冲区的当前位置
put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position)

🔔 注意

capacity：容量（长度）limit：界限（最多能读写到哪里）position：位置（读写哪个索引）
获取缓冲区里面数据之前，需要调用flip方法
再次写入数据之前，需要第哦啊用clear方法，但是数据还未消失，等再次写入数据，被覆盖才会消失。

2.5 Channel通道

2.5.1概述

通道（Channel）：由 java.nio.channels 包定义的。Channel 表示 IO 源与目标打开的连接。 Channel 类似于传统的“流”。只不过 Channel 本身不能直接访问数据，Channel 只能与 Buffer 进行交互。

1、 NIO 的通道类似于流，但有些区别如下：

通道可以同时进行读写，而流只能读或者只能写
通道可以实现异步读写数据
通道可以从缓冲读数据，也可以写数据到缓冲:

2、BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel)
是双向的，可以读操作，也可以写操作。

3、Channel 在 NIO 中是一个接口

public interface Channel extends Closeable{}

2.5.2 常用实现类

FileChannel：用于读取、写入、映射和操作文件的通道。
DatagramChannel：通过 UDP 读写网络中的数据通道。
SocketChannel：通过 TCP 读写网络中的数据。
ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】

2.5.3 获取通道方法

getChannel()方法：对支持通道的对象调用getChannel()方法。

支持通道的类如下：
- FileInputStream
- FileOutputStream
- RandomAccessFile
- DatagramSocket
- Socket
- SeverSocket
Files.newByteChannel() 静态方法
调用指定通道的open()静态方法打开并返回指定通道。

2.6 Selector选择器

2.6.1 基本介绍

可以用一个线程，处理多个客户端连接，就会使用到NIO的Selector，Selector能够检测多个注册的服务端通道上是否有事件发生，如果有事件发生，便获取然后针对每个事件进行响应的处理。这样就可以只用一个线程去管理多个通道，也就是管理多个连接和请求。

在这里插入图片描述

2.6.2 常用API介绍

Selector是一个抽象类

在这里插入图片描述

常用方法

Selector.open(); 得到一个选择器对象

selector.select(); 阻塞监控所有注册的通道，当有对应的时间操作时，会将SelectionKey放入集合内部并返回事件数量

selector.select(1000); 阻塞1000毫秒，监控所有注册的通道，当有对应的使劲按操作时，会将SelectKey放入集合内部并返回

selector.selectedKeys(); 返回存在有SelectKey的集合

SelectionKey

常用方法
- isAcceptable(): 是否是连接继续事件
- isConnectable(): 是否是连接就绪事件
- isReadable(): 是否是读就绪事件
- isWritable(): 是否是写就绪事件
SelectionKey中定义的4种事件
- SelectionKey.OP_ACCEPT: 接收连接继续事件，表示服务器监听到客户端连接，服务器可以接收这个连接了
- SelectionKey.OP_CONNECT: 连接就绪事件，表示客户端与服务端的连接已经建立成功
- SelectionKey.OP_READ: 读就绪事件，表示通道中已经有了可读的数据，可以执行读操作了(通道目前有数据，可以进行读操作了)
- SelectionKey.OP_WRITE: 写就绪事件，表示已经可以向通道写数据了（通道目前可以用于写操作）

二、Netty核心原理

1. Netty介绍

1.1 原生NIO存在的问题

NIO的类库和API复杂。
需要具备其他额外技能：要熟悉 Java 多线程编程，因为 NIO 编程涉及到Reactor 模式，你必须对多线程和网络编程非常熟悉，才能编写出高质量的 NIO 程序。
开发工作量和难度都非常大
JDK NIO的Bug：臭名昭著的Epoll Bug，它会导致Selector空轮询，最终导致CPU100%。

在NIO中通过Selector的轮询当前是否有IO事件，根据JDK NIO api描述，Selector的select方法会一直阻塞，直到IO事件达到或超时，但是在Linux平台上这里有时会出现问题，在某些场景下select方法会直接返回，即使没有超时并且也没有IO事件到达，这就是著名的epollbug，这是一个比较严重的bug，它会导致线程陷入死循环，会让CPU飙到100%，极大地影响系统的可靠性，到目前为止，JDK都没有完全解决这个问题

1.2 概述

Netty 是一个异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。Netty是一个基于NIO的网络编程框架。

在这里插入图片描述

从图中能够看出Netty的强大之处：零拷贝，可扩展事件模型，支持TCP、UDP、HTTP、WebSocket等协议，提供安全传输，压缩，大文件传输，编解码支持等。

具备如下优点:

设计优雅，提供阻塞和非阻塞的 Socket；提供灵活可拓展的事件模型；提供高度可定制的线程模型。
具备更高的性能和更大的吞吐量，使用零拷贝技术最小化不必要的内存复制，减少资源的消耗。
提供安全传输特性。
支持多种主流协议；预置多种编解码功能，支持用户开发私有协议

2. 线程模型

2.1 线程模型基本介绍

不同的线程模式，对程序的性能有很大影响，在学习Netty线程模式之前，首先讲解下各个线程模式，最后看看 Netty 线程模型有什么优越性.目前存在的线程模型有：

传统阻塞 I/O 服务模型
Reactor 模型
根据 Reactor 的数量和处理资源池线程的数量不同，有 3 种典型的实现
- 单 Reactor 单线程
- 单 Reactor 多线程
- 主从 Reactor 多线程

2.2 传统阻塞IO服务模型

采用阻塞 IO 模式获取输入的数据, 每个连接都需要独立的线程完成数据的输入 , 业务处理和数据返回工作.

在这里插入图片描述

存在问题:

当并发数很大，就会创建大量的线程，占用很大系统资源
连接创建后，如果当前线程暂时没有数据可读，该线程会阻塞在 read 操作，造成线程资源浪费

2.3 Reactor模型

Reactor模型，通过一个或多个输入同时传递给服务器的模型，服务端程序处理传入的多个请求，并将它们同步分派到响应的处理线程，因此Reactor模式也叫Dispatcher模式，Reactor模式使用IO复用监听事件，接收事件后，分发给某个线程，这点就是网络服务器高并发处理关键。

1. 单Reactor单线程

在这里插入图片描述

Selector是可以实现应用程序通过一个阻塞对象监听多路连接请求
Reactor对象通过Selector对象建通客户端请求事件，收到请求后通过Dispatch进行分发
是建立连接事件，则由Acceptor通过Accept处理连接请求，然后创建一个Handler对象处理连接完成后续业务流程
Handler会完成Read->业务处理->Send 的完整业务流程

优点：模型简单，没有多线程、进程通信、竞争的问题，全部都在一个线程中完成

缺点：

性能问题: 只有一个线程，无法完全发挥多核 CPU 的性能。Handler 在处理某个连接上的业务时，整个进程无法处理其他连接事件，很容易导致性能瓶颈
可靠性问题: 线程意外终止或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障

2. 单Reactor多线程

在这里插入图片描述

Reactor对象通过selector监控客户端请求事件，收到事件后，通过dispatch进行分发
如果建立连接请求，则由Acceptor通过accept处理连接请求。
如果不是连接请求，则由reactor分发调用连接对应的handler来处理
handler只负责响应事件，不做具体的业务逻辑，通过read读取数据后，会分发给后面的worker线程池的某个线程处理业务
worker线程池会分配独立线程完成真正的业务，并将结果返回给handler
handler收到响应后，通过send将结果返回给client

优点：可以充分的利用多核cpu的处理能力

缺点：多线程的数据共享和访问比较复杂，reactor处理多有的事件的监听和响应，在单线程运行，在高并发场景容易出现性能瓶颈

3. 主从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 线程能够应对更高的并发请求

缺点:

MainReactor 线程与 SubReactor 线程的数据交互简单职责明确，MainReactor 线程只需要接收新连接，SubReactor 线程完成后续的业务处理
MainReactor 线程与 SubReactor 线程的数据交互简单， MainReactor 线程只需要把新连接传给 SubReactor 线程，SubReactor 线程无需返回数据
多个 SubReactor 线程能够应对更高的并发请求

缺点:
这种模式的缺点是编程复杂度较高。但是由于其优点明显，在许多项目中被广泛使用，包括Nginx、Memcached、Netty 等。这种模式也被叫做服务器的 1+M+N 线程模式，即使用该模式开发的服务器包含一个（或多个，1 只是表示相对较少）连接建立线程+M 个 IO 线程+N 个业务处理线程。这是业界成熟的服务器程序设计模式

3. Netty线程模型

Netty的设计主要基于主从Reactor多线程模式，并做了一些改进

1. 简单版Netty模型

在这里插入图片描述

BossGroup 线程维护 Selector，ServerSocketChannel 注册到这个 Selector 上，只关注连接建立请求事件（主 Reactor）
当接收到来自客户端的连接建立请求事件的时候，通过 ServerSocketChannel.accept 方法获得对应的 SocketChannel，并封装成 NioSocketChannel 注册到 WorkerGroup 线程中的Selector，每个 Selector 运行在一个线程中（从 Reactor）
当 WorkerGroup 线程中的 Selector 监听到自己感兴趣的 IO 事件后，就调用 Handler 进行处理

2. 进阶版Netty模型

在这里插入图片描述

有两组线程池：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模型

在这里插入图片描述

Netty 抽象出两组线程池：BossGroup 和 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 上的
- runAllTasks：再去以此循环处理任务队列中的其他任务
每个 WorkerNioEventLoop 中循环执行以下三个步骤
- select：轮训注册在其上的 NioSocketChannel 的 read/write 事件（OP_READ/OP_WRITE 事件）
- processSelectedKeys：在对应的 NioSocketChannel 上处理 read/write 事件
- runAllTasks：再去以此循环处理任务队列中的其他任务
在以上两个processSelectedKeys步骤中，会使用 Pipeline（管道），Pipeline 中引用了Channel，即通过 Pipeline 可以获取到对应的 Channel，Pipeline 中维护了很多的处理器（拦截处理器、过滤处理器、自定义处理器等）

4. 核心API介绍

4.1 ChannelHandler及其实现类

ChannelHandler接口定义了许多事件处理方法，可以通过重写这些方法实现具体的业务逻辑。

在这里插入图片描述

Netty开发中需要自定义一个Handler类去实现ChannelHandler接口或其子接口或其实现类，然后重写相应方法实现业务逻辑

void channelActive(ChannelHandlerContext var1) throws Exception; // 通道就绪事件

void channelRead(ChannelHandlerContext var1, Object var2) throws Exception; // 通道读取事件

void channelReadComplete(ChannelHandlerContext var1) throws Exception; // 通道读取完毕事件

void exceptionCaught(ChannelHandlerContext var1, Throwable var2) throws Exception; // 通道异常事件

4.2 ChannelPipeline

channelPipeline是一个Handler的集合，负责处理和拦截inbound或者outbound的事件和操作，相当于一个贯穿Netty的责任链。

在这里插入图片描述

如果客户端和服务器的Handler是一样的，消息从客户端或者反过来，每个Inbound类型或者Outbound类型的Handler只会经过一次，混合类型的Handler（实现了Inbound和Outbound的Handler）会经过两次。准确的说ChannelPipeline中是一个ChannelHandlerContext，每个上下文对象中有ChannelHandler. InboundHandler是按照Pipeline的加载顺序的顺序执行，OutboundHandler是按照Pipeline的加载顺序，逆序执行

4.3 ChannelHandlerContext

这是处理器上下文对象，Pipeline链中的实际处理节点，每个处理节点ChannelHandlerContext中包含一个具体的事件处理器ChannelHandler，同时ChannelHandlerContext中也绑定了对应的ChannelPipeline和Channel的信息，方便对ChannelHandler进行调用，常用方法如下所示：

```
ChannelFuture close(); // 关闭通道
```

ChannelOutboundInvoker flush(); // 刷新

ChannelFuture writeAndFlush(Object var1); // 将数据写到ChannelPipeline中当前ChannelHandler的下一个ChannelHandler开始处理（出栈）

4.4 ChannelOption

Netty在创建Channel实例后，一般都需要设置ChannelOption参数，ChannelOption是Socket的标准参数，而非Netty独创的。常用的参数配置有：

ChannelOption.SO_BACKLOG

对应TCP/IP 协议listen函数中的backlog参数，用来初始化服务器可连接队列的大小，服务端处理客户端连接请求是顺序处理的，所以同一时间只能处理一个客户端连接，多个客户端来的时候，服务端将不能处理的客户端连接请求放到队列中等待处理，backlog指定队列的大小。
ChannelOption.SO_KEEPALIVE

一直保持连接活动状态。该参数用于设置TCP连接，当设置该选项以后，连接会测试链接的状态，这个选项用于可能长时间没有数据交流的连接。当设置该选项以后，如果在两小时内没有数据的通信时，TCP会自动发送一个活动探测数据报文。

4.5 ChannelFuture

表示Channel中异步IO操作的结果，在Netty中所有IO操作都是异步的，IO的调用会直接返回，调用者不能立即获得结果，但是可以通过ChannelFuture来获得IO操作的处理状态。

常用方法如下：

Channel channel(); // 返回当前正在进行IO操作的通道

ChannelFuture sync() throws InterruptedException; // 等待异步操作执行完毕，将异步改为同步

4.6 EventLoopGroup和实现类NioEventLoopGroup

EventLoopGroup是一组EventLoop的抽象，Netty为了更好的利用多核CPU资源，一般会有多个EventLoop同时工作，每个EventLoop维护着一个Selector实例。

EeventLoopGroup提供next接口，可以从组里按照一定规则获取其中一个EventLoop来处理任务。在Netty服务端中，一般会提供两个EventLoopGroup，例如：BossEventLoopGroup和WorkerEventLoopGroup。通常一个服务端口即一个SeverSocketChannel对应一个Selector和一个EventLoop线程。BossEventLoop负责接收客户端的连接并将SocketChannel交给WorkerEventLoopGroup来进行IO处理。

如下图：

在这里插入图片描述

BossEventLoopGroup通常是一个单线程的EventLoop，EventLoop维护一个注册了ServerSocketChannel的Seleor实例，BossEventLoop 不断轮询Selector将连接事件分离出来，通常是OP_ACCPET事件，然后将接收到的SocketChannel交给WorkerEventLoopGroup，WorkerEventLoopGroup会由next选择其中一个EventLoopGroup来将这个SocketChannel注册到其维护的Seletor并对其后续的IO事件进行处理。

一般情况都是使用实现类NioEventLoopGroup.

常用方法如下：

Future<?> shutdownGracefully(); // 断开连接，关闭线程 （优雅地）

4.7 ServerBootstrap和Bootstrap

ServerBootstap是Netty中的服务端启动助手，通过它可以完成服务端的各种配置；

Bootstrap是Netty中的客户端的启动助手，通过它可以完成客户端的各种配置。

常用方法如下：

public ServerBootstrap group(EventLoopGroup parentGroup, EventLoopGroup childGroup) // 该方法用于服务器端，用来设置两个EventLoop

public B group(EventLoopGroup group) // 该方法用于客户端，用来设置一个EventLoop

public B channel(Class<? extends C> channelClass)  // 该方法用来设置一个服务器端的通道实现

public <T> B option(ChannelOption<T> option, T value) // 用来给SeverChannel添加配置

public <T> ServerBootstrap childOption(ChannelOption<T> childOption, T value) // 用来给接收到的通道添加配置

public ServerBootstrap childHandler(ChannelHandler childHandler) // 该方法用来设置业务处理类（自定义Handler）

public ChannelFuture bind(int inetPort) // 该方法用于服务器端，来设置占用端口

public ChannelFuture connect(InetAddress inetHost, int inetPort) // 该方法用于客户端，用来连接服务器端

4.8 Unpooled类

这是Netty提供的一个专门用来操作缓冲区的工具类，常用方法如下所示：

public static ByteBuf copiedBuffer(CharSequence string, Charset charset) // 通过给定的数据和字符编码返回一个ByteBuf对象（类似NIO中的ByteBuffer对象）

5. Netty案例-群聊天室

5.1 案例需求

编写一个 Netty 群聊系统，实现服务器端和客户端之间的数据简单通讯
实现多人群聊
服务器端：可以监测用户上线，离线，并实现消息转发功能
客户端：可以发送消息给其它所有用户，同时可以接受其它用户发送的消息

5.2 聊天室服务端编写

NettyChatServer

package com.szile.netty.chat;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 * 聊天室服务端
 */
public class NettyChatServer {

    private int port;

    public NettyChatServer(int port) {
        this.port = port;
    }

    public void run() throws InterruptedException {
        // 1. 创建bossGroup线程组，处理网络事件-连接事件
        /* 设置线程数据, 不设置默认是2*处理线程数 */
        NioEventLoopGroup bossGroup = null;
        // 2. 创建workerGroup线程组：处理网络事件-读写事件
        NioEventLoopGroup workerGroup = null;

        try {
            // 1. 创建bossGroup线程组，处理网络事件-连接事件
            /* 设置线程数据, 不设置默认是2*处理线程数 */
            bossGroup = new NioEventLoopGroup(1);
            // 2. 创建workerGroup线程组：处理网络事件-读写事件
            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 socketChannel) throws Exception {
                            // 8. 向pipeline中减价自定义业务处理handler
                            // socketChannel.pipeline().addLast(new NettyServerHandler());
                            socketChannel.pipeline().addLast(new StringDecoder());
                            socketChannel.pipeline().addLast(new StringEncoder());

                            socketChannel.pipeline().addLast(new NettyChartServerHandler());
                        }
                    })
            ;

            // 9. 启动服务端并绑定端口，同时将异步改为同步
            ChannelFuture channelFuture = serverBootstrap.bind(port);
            channelFuture.addListener(new ChannelFutureListener() {
                @Override
                public void operationComplete(ChannelFuture channelFuture) throws Exception {
                    if (channelFuture.isSuccess()) {
                        System.out.println("端口绑定成功！");
                    } else {
                        System.out.println("端口绑定失败！");
                    }
                }
            });

            System.out.println("聊天室服务端启动成功");
            // 10. 关闭通道【并不是真正意义上的关闭，而是监听通道关闭的状态】和关闭连接池
            channelFuture.channel().closeFuture().sync();

        } finally {
            if (bossGroup != null)
                bossGroup.shutdownGracefully();
            if (workerGroup != null)
                workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new NettyChatServer(9998).run();
    }
}

NettyChatServerHandler

package com.szile.netty.chat;

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

import java.util.ArrayList;
import java.util.List;

/**
 * 聊天室业务处理类
 */
public class NettyChatServerHandler extends SimpleChannelInboundHandler<String> {

    public static List<Channel> channelList = new ArrayList<>();

    /**
     * 通道就绪事件 有客户但连接
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        // 当有新的客户端连接的时候将通道放入集合
        channelList.add(channel);

        System.out.println("【server】：" + channel.remoteAddress().toString().substring(1) + "上线！");
    }

    /**
     * 通道未就绪 下线
     *
     * @param ctx
     * @throws Exception
     */
    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {

        Channel channel = ctx.channel();

        channelList.remove(channel);
        System.out.println("【server】：" + channel.remoteAddress().toString().substring(1) + "下线！");
    }


    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

        cause.printStackTrace();
        Channel channel = ctx.channel();
        channelList.remove(channel);
        System.out.println("【server】：" + channel.remoteAddress().toString().substring(1) + "异常！");

    }

    /**
     * 通道读取事件
     *
     * @param channelHandlerContext
     * @param s
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, String s) throws Exception {
        // 当前发送消息的通道
        Channel channel = channelHandlerContext.channel();

        for (Channel channel1 : channelList) {
            if (channel != channel1) {
                channel1.writeAndFlush("【" + channel.remoteAddress().toString().substring(1) + "】：" + s);
            }
        }
    }
}

聊天室客户端编写

NettyChatClient

package com.szile.netty.chat;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
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;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.util.Scanner;

public class NettyChatClient {

    private String ip;
    private int port;

    public NettyChatClient(String ip, int port) {
        this.ip = ip;
        this.port = port;
    }

    public void run() throws InterruptedException {
        EventLoopGroup eventLoopGroup = null;
        try {
            eventLoopGroup = new NioEventLoopGroup();
            // 2. 创建客户端启动助手
            Bootstrap bootstrap = new Bootstrap();
            // 3. 设置线程组
            bootstrap.group(eventLoopGroup)
                    .channel(NioSocketChannel.class) // 4. 设置客户端通道模式为NIO
                    .handler(new ChannelInitializer<SocketChannel>() { // 5. 创建一个通道初始化对象
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            // 6. 向pipeline中添加自定义的业务处理类handler
                            // socketChannel.pipeline().addLast(new NettyClientHandler());
                            // todo
                            socketChannel.pipeline().addLast(new StringDecoder());
                            socketChannel.pipeline().addLast(new StringEncoder());

                            socketChannel.pipeline().addLast(new NettyChatClientHandler());
                        }
                    });
            // 7. 启动客户端，等待连接服务端，同时将异步改为同步
            ChannelFuture channelFuture = bootstrap.connect(ip, port).sync();
            Channel channel = channelFuture.channel();
            System.out.println("---" + channel.localAddress().toString().substring(1) + "---");
            Scanner scanner = new Scanner(System.in);

            while (scanner.hasNextLine()) {
                String nextLine = scanner.nextLine();
                // 向服务端发送消息
                channel.writeAndFlush(nextLine);

            }

            // 8. 关闭通道和关闭连接池
            channelFuture.channel().closeFuture().sync();

        } finally {
            if (eventLoopGroup != null)
                eventLoopGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new NettyChatClient("127.0.0.1", 9998).run();
    }
}

NettyChatClientHandler

package com.szile.netty.chat;

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

/**
 */
public class NettyChatClientHandler extends SimpleChannelInboundHandler<String> {
    /**
     * 通道就绪事件
     *
     * @param channelHandlerContext
     * @param s
     * @throws Exception
     */
    @Override
    protected void channelRead0(ChannelHandlerContext channelHandlerContext, String s) throws Exception {
        System.out.println(s);
    }
}

超人@不会飞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
NIO&Netty

一、IO模型1. I/O模型说明IO模型就是用什么样的通道进行数据的发送给和接收，很大程度上决定了程序通信的性能。Java共支持3种网络编程模型：BIO(同步并阻塞)、NIO(同步非阻塞)、AIO(异步非阻塞)1.1 BIO 同步并阻塞Java BIO就是传统的socket编程。BIO ：同步并阻塞，服务器实现模式是一个链接一个线程，即客户端有连接请求时服务器就启动一个线程进行处理，如果这个线程不做任何事情就会造成不必要的线程开销。BIO 问题分析每个请求都要创建新的线程，来处理客户端的
复制链接

扫一扫