Netty之JavaNIO编程模型介绍01

古城微笑少年丶 2023-06-25 10:18 16阅读 0赞

我们在前面的BIO的基础上我们来继续介绍下NIO的内容

# 一、Java NIO 基本介绍 #

Java NIO 全称 java non-blocking IO，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO(即 New IO)，是`同步非阻塞的`

NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。

NIO 三大核心

Channel-通道

Buffer-缓冲区

Selector-选择器

NIO是`面向缓冲区` ，或者面向 `块` 编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络  
  Java NIO的`非阻塞模式`，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。

通俗理解：NIO是可以做到用一个线程来处理多个操作的。假设有10000个请求过来,根据实际情况，可以分配50或者100个线程来处理。不像之前的阻塞IO那样，非得分配10000个。

HTTP2.0使用了`多路复用`的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比HTTP1.1大了好几个数量级。

# 二、NIO和BIO的比较 #

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

# 三、NIO三大核心 #

下图描述了 Buffer，Channel，Selector三者的关系  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70]

1.  每个channel 都会对应一个Buffer
2.  Selector 对应一个线程， 一个线程对应多个channel(连接)
3.  该图反应了有三个channel 注册到 该selector //程序
4.  程序切换到哪个channel 是有事件决定的, Event 就是一个重要的概念
5.  Selector 会根据不同的事件，在各个通道上切换
6.  Buffer 就是一个内存块 ， 底层是有一个数组
7.  数据的读取写入是通过Buffer, 这个和BIO , BIO 中要么是输入流，或者是输出流, 不能双向，但是NIO的Buffer 是可以读也可以写, 需要 flip 方法切换channel 是双向的, 可以返回底层操作系统的情况, 比如Linux ， 底层的操作系统
8.  通道就是双向的.

## 3.1缓冲区Buffer ##

### 基本介绍 ###

缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象(含数组)，该对象提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer，

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 1]

### Buffer 类及其子类 ###

1.  在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类, 类的层级关系图:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 2]  
通过名称也比较直观的能看出每个具体Buffer的作用。

1.  Buffer类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息:

private int mark = -1;
        private int position = 0;
        private int limit;
        private int capacity;

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th align="left">描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Capacity</td> 
   <td align="left">容量，即可以容纳的最大数据量；在缓冲区创建时被设定并且不能改变</td> 
  </tr> 
  <tr> 
   <td>Limit</td> 
   <td align="left">表示缓冲区的当前终点，不能对缓冲区超过极限的位置进行读写操作。且极限是可以修改的</td> 
  </tr> 
  <tr> 
   <td>Position</td> 
   <td align="left">位置，下一个要被读或写的元素的索引，每次读写缓冲区数据时都会改变改值，为下次读写作准备</td> 
  </tr> 
  <tr> 
   <td>Mark</td> 
   <td align="left">标记</td> 
  </tr> 
 </tbody> 
</table>

1.  Buffer类相关方法一览

public abstract class Buffer { 
        //JDK1.4时，引入的api
        public final int capacity( )//返回此缓冲区的容量
        public final int position( )//返回此缓冲区的位置
        public final Buffer position (int newPositio)//设置此缓冲区的位置
        public final int limit( )//返回此缓冲区的限制
        public final Buffer limit (int newLimit)//设置此缓冲区的限制
        public final Buffer mark( )//在此缓冲区的位置设置标记
        public final Buffer reset( )//将此缓冲区的位置重置为以前标记的位置
        public final Buffer clear( )//清除此缓冲区, 即将各个标记恢复到初始状态，但是数据并没有真正擦除, 后面操作会覆盖
        public final Buffer flip( )//反转此缓冲区
        public final Buffer rewind( )//重绕此缓冲区
        public final int remaining( )//返回当前位置与限制之间的元素数
        public final boolean hasRemaining( )//告知在当前位置和限制之间是否有元素
        public abstract boolean isReadOnly( );//告知此缓冲区是否为只读缓冲区
     
        //JDK1.6时引入的api
        public abstract boolean hasArray();//告知此缓冲区是否具有可访问的底层实现数组
        public abstract Object array();//返回此缓冲区的底层实现数组
        public abstract int arrayOffset();//返回此缓冲区的底层实现数组中第一个缓冲区元素的偏移量
        public abstract boolean isDirect();//告知此缓冲区是否为直接缓冲区
    }

1.  ByteBuffer  
      从前面可以看出对于 Java 中的基本数据类型(boolean除外)，都有一个 Buffer 类型与之相对应，最常用的自然是ByteBuffer 类（二进制数据），该类的主要方法如下

public abstract class ByteBuffer { 
        //缓冲区创建相关api
        public static ByteBuffer allocateDirect(int capacity)//创建直接缓冲区
        public static ByteBuffer allocate(int capacity)//设置缓冲区的初始容量
        public static ByteBuffer wrap(byte[] array)//把一个数组放到缓冲区中使用
        //构造初始化位置offset和上界length的缓冲区
        public static ByteBuffer wrap(byte[] array,int offset, int length)
         //缓存区存取相关API
        public abstract byte get( );//从当前位置position上get，get之后，position会自动+1
        public abstract byte get (int index);//从绝对位置get
        public abstract ByteBuffer put (byte b);//从当前位置上添加，put之后，position会自动+1
        public abstract ByteBuffer put (int index, byte b);//从绝对位置上put
     }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 3]

## 3.2 通道Channel ##

### 基本介绍 ###

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

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 4]  
2) BIO 中的 stream 是单向的，例如 FileInputStream 对象只能进行读取数据的操作，而 NIO 中的通道(Channel)是双向的，可以读操作，也可以写操作。  
3) Channel在NIO中是一个接口public interface Channel extends Closeable\{\}  
4) 常用的 Channel 类有：FileChannel、DatagramChannel、ServerSocketChannel 和 SocketChannel。【ServerSocketChanne 类似 ServerSocket , SocketChannel 类似 Socket】

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 5]

1.  FileChannel 用于文件的数据读写，DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。

### FileChannel 类 ###

FileChannel主要用来对本地文件进行 IO 操作，常见的方法有

public int read(ByteBuffer dst) ，从通道读取数据并放到缓冲区中
    public int write(ByteBuffer src) ，把缓冲区的数据写到通道中
    public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道中复制数据到当前通道
    public long transferTo(long position, long count, WritableByteChannel target)，把数据从当前通道复制给目标通道

### 实例1-本地文件写数据 ###

通过前面介绍的内容完成一些简单的NIO文件操作，代码如下：

package com.dpb.netty.nio;
    
    import java.io.FileOutputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    /** * @program: netty4demo * @description: * @author: 波波烤鸭 * @create: 2019-12-28 11:37 */
    public class NioChannel01 { 
    
        public static void main(String[] args) throws Exception{ 
    
            String str = "hello,bobokaoya";
            //创建一个输出流->channel
            FileOutputStream fileOutputStream = new FileOutputStream("c:\\tools\\netty.txt");
    
            //通过 fileOutputStream 获取 对应的 FileChannel
            //这个 fileChannel 真实 类型是 FileChannelImpl
            FileChannel fileChannel = fileOutputStream.getChannel();
    
            //创建一个缓冲区 ByteBuffer
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
    
            //将 str 放入 byteBuffer
            byteBuffer.put(str.getBytes());
    
    
            //对byteBuffer 进行flip
            byteBuffer.flip();
    
            //将byteBuffer 数据写入到 fileChannel
            fileChannel.write(byteBuffer);
            fileOutputStream.close();
        }
    }

![在这里插入图片描述][20191228114059652.gif]

### 实例2-本地文件读数据 ###

package com.dpb.netty.nio;
    
    import java.io.File;
    import java.io.FileInputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    /** * @program: netty4demo * @description: * @author: 波波烤鸭 * @create: 2019-12-28 11:41 */
    public class NioChannel02 { 
        public static void main(String[] args) throws Exception { 
    
            //创建文件的输入流
            File file = new File("c:\\tools\\netty.txt");
            FileInputStream fileInputStream = new FileInputStream(file);
    
            //通过fileInputStream 获取对应的FileChannel -> 实际类型 FileChannelImpl
            FileChannel fileChannel = fileInputStream.getChannel();
    
            //创建缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
    
            //将 通道的数据读入到Buffer
            fileChannel.read(byteBuffer);
    
            //将byteBuffer 的 字节数据 转成String
            System.out.println(new String(byteBuffer.array()));
            fileInputStream.close();
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 6]

### 实例3-使用一个Buffer完成文件读取 ###

package com.dpb.netty.nio;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.nio.ByteBuffer;
    import java.nio.channels.FileChannel;
    
    /** * @program: netty4demo * @description: * @author: 波波烤鸭 * @create: 2019-12-28 11:44 */
    public class NioChannel03 { 
        public static void main(String[] args) throws Exception { 
    
            FileInputStream fileInputStream = new FileInputStream("1.txt");
            FileChannel fileChannel01 = fileInputStream.getChannel();
    
            FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
            FileChannel fileChannel02 = fileOutputStream.getChannel();
    
            ByteBuffer byteBuffer = ByteBuffer.allocate(512);
    
            while (true) {  //循环读取
    
                //这里有一个重要的操作，一定不要忘了
                /* public final Buffer clear() { position = 0; limit = capacity; mark = -1; return this; } */
                byteBuffer.clear(); //清空buffer
                int read = fileChannel01.read(byteBuffer);
                System.out.println("read =" + read);
                if(read == -1) {  //表示读完
                    break;
                }
                //将buffer 中的数据写入到 fileChannel02 -- 2.txt
                byteBuffer.flip();
                fileChannel02.write(byteBuffer);
            }
    
            //关闭相关的流
            fileInputStream.close();
            fileOutputStream.close();
        }
    }

![在这里插入图片描述][20191228114804740.gif]

### 实例4-拷贝文件transferFrom 方法 ###

接下来我们同transferFrom方法来实现一个文件的复制操作。

package com.dpb.netty.nio;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.nio.channels.FileChannel;
    
    /** * @program: netty4demo * @description: * @author: 波波烤鸭 * @create: 2019-12-28 11:49 */
    public class NioChannel04 { 
        public static void main(String[] args)  throws Exception { 
    
            //创建相关流
            FileInputStream fileInputStream = new FileInputStream("c:\\tools\\a1.jpg");
            FileOutputStream fileOutputStream = new FileOutputStream("c:\\tools\\a2.jpg");
    
            //获取各个流对应的filechannel
            FileChannel sourceCh = fileInputStream.getChannel();
            FileChannel destCh = fileOutputStream.getChannel();
    
            //使用transferForm完成拷贝
            destCh.transferFrom(sourceCh,0,sourceCh.size());
            //关闭相关通道和流
            sourceCh.close();
            destCh.close();
            fileInputStream.close();
            fileOutputStream.close();
        }
    }

![在这里插入图片描述][20191228115156104.gif]

### 关于Buffer 和 Channel的注意事项和细节 ###

1.  ByteBuffer 支持类型化的put 和 get, put 放入的是什么数据类型，get就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常。
2.  可以将一个普通Buffer 转成只读Buffer \[举例说明\]  
    NIO 还提供了 MappedByteBuffer， 可以让文件直接在内存（堆外的内存）中进行修改， 而如何同步到文件由NIO 来完成.
3.  前面我们讲的读写操作，都是通过一个Buffer 完成的，NIO 还支持 通过多个Buffer (即 Buffer 数组) 完成读写操作，即 Scattering 和 Gathering

## 3.3 选择器Selector ##

### 基本介绍 ###

Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到Selector(选择器)

Selector 能够检测多个注册的通道上是否有事件发生(注意:多个Channel以事件的方式可以注册到同一个Selector)，如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 7]

只有在 连接/通道 真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程  
避免了多线程之间的上下文切换导致的开销

特点再说明:

1.  Netty 的 IO 线程 NioEventLoop 聚合了 Selector(选择器，也叫多路复用器)，可以同时并发处理成百上千个客户端连接。
2.  当线程从某客户端 Socket 通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。
3.  线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO 操作，所以单独的线程可以管理多个输入和输出通道。
4.  由于读写操作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁 I/O 阻塞导致的线程挂起。
5.  一个 I/O 线程可以并发处理 N 个客户端连接和读写操作，这从根本上解决了传统同步阻塞 I/O 一连接一线程模型，架构的性能、弹性伸缩能力和可靠性都得到了极大的提升。

### Selector类相关方法 ###

Selector 类是一个抽象类, 常用方法和说明如下:

public abstract class Selector implements Closeable {  
    public static Selector open();//得到一个选择器对象
    //监控所有注册的通道，当其中有 IO 操作可以进行时，将对应的 SelectionKey 加入到内部集合中并返回，参数用来设置超时时间
    public int select(long timeout);
    public Set<SelectionKey> selectedKeys();//从内部集合中得到所有的 SelectionKey 
    }

### 注意事项 ###

NIO中的 ServerSocketChannel功能类似ServerSocket，SocketChannel功能类似Socket  
selector 相关方法说明

selector.select()//阻塞
    selector.select(1000);//阻塞1000毫秒，在1000毫秒后返回
    selector.wakeup();//唤醒selector
    selector.selectNow();//不阻塞，立马返还

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2019122811174167.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191228112117611.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191228112300900.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191228112859873.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20191228113150390.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191228113321915.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[20191228114059652.gif]: https://img-blog.csdnimg.cn/20191228114059652.gif
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191228114405940.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70
[20191228114804740.gif]: https://img-blog.csdnimg.cn/20191228114804740.gif
[20191228115156104.gif]: https://img-blog.csdnimg.cn/20191228115156104.gif
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191228140056236.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9kcGItYm9ib2thb3lhLXNtLmJsb2cuY3Nkbi5uZXQ=,size_16,color_FFFFFF,t_70