NIO

数据定义缓冲区容器

img

  1. NIO中有几个核心对象需要掌握：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。
  2. img

官方API介绍

NIO api的核心抽象:

  • Buffers，容器数据;
  • Charsets及其相关解码器和编码器,字节和Unicode字符之间的转换;
  • Channels各种类型的,这表示连接实体能够执行I / O操作;和
  • 选择器和选择键,连同可选择的渠道定义一个multiplexed、non-blocking、I/O设施。
  • java.nio包定义缓冲区类,用于在整个NIO api。
  • java.nio.charset 包定义字符集API 。
  • 通道选择器API中定义java.nio.channels包。这些子包都有自己的服务提供者(SPI)分装,可用于扩展的内容或构建替代实现平台的默认实现。
Buffers 描述
Buffer Position, limit, and capacity; clear, flip, rewind, and mark/reset
ByteBuffer Get/put, compact, views; allocate, wrap
MappedByteBuffer A byte buffer mapped to a file
CharBuffer Get/put, compact; allocate, wrap
DoubleBuffer ‘ ‘
FloatBuffer ‘ ‘
IntBuffer ‘ ‘
LongBuffer ‘ ‘
ShortBuffer ‘ ‘
ByteOrder Typesafe enumeration for byte orders

一个缓冲是一个固定的容器的数据量的一个特定的原始类型。

除了其内容缓冲区的位置,这是下一个元素的索引读取或写入,以及限制,这是第一个元素的索引,不应该读或写。Buffer基类定义这些属性以及方法清算,翻转,和复卷,对标记当前位置,和重置位置前面的标志。

有一个缓冲区类为每个non-boolean原始类型。每个类定义了一个家庭得的到,把移动数据的方法和在一个缓冲区,方法压实、复制,和切片一个缓冲区,和静态方法分配一个新的缓冲区以及包装现有的数组缓冲区。

字节缓冲区是有区别的,因为它们可以作为I / O操作的源和目标。他们也支持一些特性没有找到其他缓冲区类:

  • 可以分配一个字节缓冲区direct缓冲区,在这种情况下,Java虚拟机将尽最大努力来执行本地直接I / O操作。
  • 可以创建一个字节缓冲区直接通过mapping 区域文件到内存中,在这种情况下,一些额外的定义与操作MappedByteBuffer类是可用的。
  • 一个字节缓冲区提供对其内容的访问异构或均匀的binary data序列任何non-boolean原始类型,在高位优先或低位优先byte order。

除非另外注明,null参数传递给构造函数或方法在任何类或接口在这个包将导致NullPointerException抛出。

阻塞（Blocking）、非阻塞（NonBlock）

  • 阻塞和非阻塞关注的是程序在等待调用结果（消息，返回值）时的状态。
  • 阻塞调用是指调用结果返回之前，当前线程会被挂起。调用线程只有在得到结果之后才会返回。
  • 非阻塞调用指在不能立刻得到结果之前，该调用不会阻塞当前线程。

例故事：老王烧开水。

出场人物：老张，水壶两把（普通水壶，简称水壶；会响的水壶，简称响水壶）。老王想了想，有好几种等待方式

  1. 同步阻塞-老王用水壶煮水，并且站在那里，不管水开没开，每隔一定时间看看水开了没。
  2. 同步非阻塞-老王还是用水壶煮水，不再傻傻的站在那里看水开，跑去寝室上网，但是还是会每隔一段时间过来看看水开了没有，水没有开就走人。
  3. 异步阻塞-老王这次使用高大上的响水壶来煮水，站在那里，但是不会再每隔一段时间去看水开，而是等水开了，水壶会自动的通知他。
  4. 异步非阻塞-老王还是使用响水壶煮水，跑到客厅上网去，等着响水壶自己把水煮熟了以后通知他。

同步(Synchronization)和异步(Async)

  1. 同步和异步都是基于应用程序使用操作系统处理IO事件所采用的方式。
  2. 同步：是应用程序要直接参与IO读写的操作。
  3. 异步：所有的IO读写交给搡作系统去处理，应用程序只需要等待通知。
  4. 同步方式在处理IO事件的时候，必须阻塞在某个方法上靣等待我们的IO事件完成(阻塞IO事件或者通过轮询IO事件的方式）。
  5. 对于异步来说，所有的IO读写都交给了操作系统。这个时候，我们可以去做其他的事情，并不要去完成真正的IO操作，当操作完成IO后.会给我们的应用程序一个通知。
  6. 同步：阻塞到IO事件，阻塞到read成则write。这个时候我们就完全不能做自己的事情，让读写方法加入到线程里面，然后阻塞线程来实现，对线程的性能开销比较大.

BIO与NIO对比

block IO与Non-block IO

  1. 区别
IO模型 IO NIO
方式 从硬盘到内存 从内存到硬盘
通信 面向流（乡村公路） 面向缓存（高速公路，多路复用技术）
处理 阻塞IO（多线程） 非阻塞IO（反应堆Reactor）
触发 无 选择器（轮询机制）

  1. 面向流(io)与面向缓冲(nio)🤡
    Java NIO和IO之间第一个最大的区别是，IO是面向流的。NIO是面向缓冲区的。

    • Java IO面向流意味着毎次从流中读一个成多个字节，直至读取所有字节，它们没有被缓存在任何地方，此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的教据，需要先将它缓存到一个缓冲区。
    • Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数裾。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

  2. 阻塞与非阻塞

    • Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。
    • Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

  3. 选择器（Selector)

    Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通里已经有可以处理的褕入，或者选择已准备写入的通道。这选择机制，使得一个单独的线程很容易来管理多个通道。

  4. 处理数据的线程数
    NIO：一个线程管理多个连接
    BIO：一个线程管理一个连接

  5. NIO和BIO读取文件

    1. BIO读取文件 ，BIO从一个阻塞的流中一行一行的读取数据.
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    package com.charjay.bio.file;

    import java.io.BufferedReader;
    import java.io.FileInputStream;
    import java.io.InputStreamReader;

    /**
     * BIO读取数据，从一个阻塞的流中，一行一行的读取
     * io.txt的内容：随便输入4行
     */
    public class ReadFile {
    	public static void main(String[] args) {
    		try{
    			FileInputStream input = new FileInputStream("e://io.txt");
    			BufferedReader reader = new BufferedReader(new InputStreamReader(input));
    			String nameLine = reader.readLine();
    			String ageLine = reader.readLine();
    			String emailLine = reader.readLine();
    			String phoneLine = reader.readLine();
    			String lastLine = reader.readLine();
    			System.out.println(nameLine);
    			System.out.println(ageLine);
    			System.out.println(emailLine);
    			System.out.println(phoneLine);
    			System.out.println(lastLine);
    			
    			input.close();
    			reader.close();
    			
    		}catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    }

    img

    1. NIO读取文件,通道是数据的载体，buffer是存储数据的地方，线程每次从buffer检查数据通知给通。
  Java



  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
package com.charjay.nio.buffer.file;

import java.io.FileInputStream;
import java.nio.Buffer;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class BufferProgram {  
    public static void main(String args[]) throws Exception {  
    	
    	//这用用的是文件IO处理
        FileInputStream fin = new FileInputStream("E:/io.txt");
        //创建文件的操作管道
        FileChannel fc = fin.getChannel();
        
        //分配一个10个大小缓冲区，说白了就是分配一个10个大小的byte数组
        ByteBuffer buffer = ByteBuffer.allocate(10);  
        output("初始化", buffer);
        
        //先读一下
        fc.read(buffer);  
        output("调用read()", buffer);  
  
        //准备操作之前，先锁定操作范围
        buffer.flip();  
        output("调用flip()", buffer);  
  
        //判断有没有可读数据
        while (buffer.remaining() > 0) {  
            byte b = buffer.get();
//            String data=new String(b,"");
             System.out.print("data="+((char)b));
        }  
        output("调用get()", buffer);  
  
        //可以理解为解锁
        buffer.clear();  
        output("调用clear()", buffer);  
  
        //最后把管道关闭
        fin.close();  
    }  
  
    
    //把这个缓冲里面实时状态给答应出来
    public static void output(String step, Buffer buffer) {  
        System.out.println(step + " : "); 
        //容量，数组大小
        System.out.print("capacity: " + buffer.capacity() + ", ");
        //当前操作数据所在的位置，也可以叫做游标
        System.out.print("position: " + buffer.position() + ", ");
        //锁定值，flip，数据操作范围索引只能在position - limit 之间
        System.out.println("limit: " + buffer.limit());  
        System.out.println("=============");
    }  
}  


  [![img](https://gitee.com/yichangkong/FigureBed/raw/master/img/20200525180017.png)](https://gitee.com/yichangkong/FigureBed/raw/master/img/20200525180017.png)

NIO缓冲区Buffer

  1. 缓冲区实际上是一个容器对象，更直接的说，其实就是一个数组。

    • 在NIO库中，所有数据都是用缓冲区处理的。
    • 在读取数据时，它是直接读到缓冲区中的；
    • 在写入数据时，它也是写入到缓冲区中的；
    • 任何时候访问 NIO 中的数据，都是将它放到缓冲区中。
    • 而在面向流I/O系统中，所有数据都是直接写入或者直接将数据读取到Stream对象中。
    • 反正不管读写到冲着缓冲区Buffer数组取的。👴

  2. 在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示：

  3. img

  4. 其中的四个属性的含义分别如下：
    容量（Capacity）：缓冲区能够容纳的数据元素的最大数量。这一个容量在缓冲区创建时被设定，并且永远不能改变。
    **上界(Limit)**：缓冲区的第一个不能被读或写的元素。或者说,缓冲区中现存元素的计数。
    **位置(Position)**：下一个要被读或写的元素的索引。位置会自动由相应的 get( )和 put( )函数更新。
    **标记(Mark)**：下一个要被读或写的元素的索引。位置会自动由相应的 get( )和 put( )函数更新。

    • Buffer的常见方法如下所示:

      flip(): 写模式转换成读模式
      rewind()：将 position 重置为 0 ，一般用于重复读。
      clear() ：
      compact(): 将未读取的数据拷贝到 buffer 的头部位。
      mark(): reset():mark 可以标记一个位置， reset 可以重置到该位置。
      Buffer 常见类型： ByteBuffer 、 MappedByteBuffer 、 CharBuffer 、 DoubleBuffer 、 FloatBuffer 、 IntBuffer 、 LongBuffer 、 ShortBuffer 。

    • 基本操作
      Buffer基础操作

 Java



 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package com.charjay.nio.buffer;
import java.nio.IntBuffer;
/**
 * 基础操作
 */
public class TestIntBuffer {
	public static void main(String[] args) {  
        // 分配新的int缓冲区，参数为缓冲区容量  
        // 新缓冲区的当前位置将为零，其界限(限制位置)将为其容量。它将具有一个底层实现数组，其数组偏移量将为零。  
        
		//分配了8个长度的int数组
		IntBuffer buffer = IntBuffer.allocate(8);  
//		capacity //数组的长度，容量
        for (int i = 0; i < buffer.capacity(); ++i) {
            int j = (i + 1);  
            // 将给定整数写入此缓冲区的当前位置，当前位置递增  
            buffer.put(j);  
        }  
  
        // 重设此缓冲区，将限制设置为当前位置，然后将当前位置设置为0
        //固定缓冲区中的某些值，告诉缓冲区，我要开始操作了，如果你再往缓冲区写数据的话，不要再覆盖我固定状态以前的数据了
        buffer.flip();
        // 查看在当前位置和限制位置之间是否有元素
        while (buffer.hasRemaining()) {  
            // 读取此缓冲区当前位置的整数，然后当前位置递增  
            int j = buffer.get();  
            System.out.print(j + "  ");  
        }
	}  
}
1
缓冲区分片，缓冲区分配，直接缓存区，缓存区映射，缓存区只读：
  • 缓冲区存取数据流程
    存数据时position会++，当停止数据读取的时候,调用flip()，此时limit=position，position=0
    读取数据时position++，一直读取到limit, clear() 清空 buffer ，准备再次被写入 (position 变成 0 ， limit 变成 capacity) 。

NIO通道

通道是一个对象，通过它可以读取和写入数据，当然了所有数据都通过Buffer对象来处理。

  1. 我们永远不会将字节直接写入通道中，相反是将数据写入包含一个或者多个字节的缓冲区。同样不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

img

  1. 在NIO中，提供了多种通道对象，而所有的通道对象都实现了Channel接口。它们之间的继承关系如下图所示：

  2. img

  3. 使用NIO读取数据
    在前面我们说过，任何时候读取数据，都不是直接从通道读取，而是从通道读取到缓冲区。所以使用NIO读取数据可以分为下面三个步骤：

    1. 从FileInputStream获取Channel

      • 创建Buffer
      • 将数据从Channel读取到Buffer中
  Java



  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package com.charjay.nio.channel;

import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileInputProgram {  
    static public void main( String args[] ) throws Exception {  
        FileInputStream fin = new FileInputStream("c:\\test.txt");  
        
        // 获取通道  
        FileChannel fc = fin.getChannel();  
          
        // 创建缓冲区  
        ByteBuffer buffer = ByteBuffer.allocate(1024);  
          
        // 读取数据到缓冲区  
        fc.read(buffer);  
        
        buffer.flip();  
          
        while (buffer.remaining() > 0) {  
            byte b = buffer.get();  
            System.out.print(((char)b));  
        }  
          
        fin.close();
    }  
}

  1. 使用NIO写入数据
    使用NIO写入数据与读取数据的过程类似，同样数据不是直接写入通道，而是写入缓冲区，可以分为下面三个步骤：

    • 从FileInputStream获取Channel

    • 创建Buffer

    • 将数据从Channel写入到Buffer中

 Java



 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package com.charjay.nio.channel;

import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;

public class FileOutputProgram {  
    static private final byte message[] = { 83, 111, 109, 101, 32,  
        98, 121, 116, 101, 115, 46 };  
  
    static public void main( String args[] ) throws Exception {  
        FileOutputStream fout = new FileOutputStream( "e:\\test.txt" );  
          
        FileChannel fc = fout.getChannel();  
          
        ByteBuffer buffer = ByteBuffer.allocate( 1024 );  
          
        for (int i=0; i<message.length; ++i) {  
            buffer.put( message[i] );  
        }  
          
        buffer.flip();   
        fc.write( buffer );  
          
        fout.close();  
    }  
}

NIO反应堆

  1. 阻塞IO模型
    在老的IO包中，serverSocket和socket都是阻塞式的，因此一旦有大规模的并发行为，而每一个访问都会开启一个新线程。这时会有大规模的线程上下文切换操作（因为都在等待，所以资源全都被已有的线程吃掉了），这时无论是等待的线程还是正在处理的线程，响应率都会下降，并且会影响新的线程。

    img

  2. NIO
    Java NIO是在jdk1.4开始使用的，它既可以说成“新IO”，也可以说成非阻塞式I/O。下面是java NIO的工作原理：

    1. 由一个专门的线程来处理所有的IO事件，并负责分发。
    2. 事件驱动机制：事件到的时候触发，而不是同步的去监视事件。
    3. 线程通讯：线程之间通过wait,notify等方式通讯。保证每次上下文切换都是有意义的。减少无谓的线程切换。
    4. img

注：每个线程的处理流程大概都是读取数据，解码，计算处理，编码，发送响应。

NIO选择器

  1. 传统的 server / client 模式会基于 TPR ( Thread per Request ) ．
    • 服务器会为每个客户端请求建立一个线程．由该线程单独负贵处理一个客户请求。
    • 这种模式带未的一个问题就是线程数是的剧增．
    • 大量的线程会增大服务器的开销，大多数的实现为了避免这个问题，都采用了线程池模型，并设置线程池线程的最大数量。
    • 这又带来了新的问题，如果线程池中有 200 个线程，而有 200 个用户都在进行大文件下载，会导致第 201 个用户的请求无法及时处理，即便第 201 个用户只想请求一个几 KB 大小的页面。
    • 传统的 Sorvor / Client 模式如下围所示：
    • img
  2. NIO 中非阻塞IO采用了基于Reactor模式的工作方式。
    • IO调用不会被阻塞，相反是注册感兴趣的特点IO事件，如可读数据到达，新的套接字等等，在发生持定率件时，系统再通知我们。
    • NlO中实现非阻塞IO的核心设计Selector，Selector就是注册各种IO事件的地方，而且当那些事件发生时，就是这个对象告诉我们所发生的事件。
  3. 当有读或者写等任何注册的事件发生时！
    • 可以从Selector中获得相应的SelectionKey，同时从SelectionKey中可以找到发生的事件和该事件所发生的具体的SelectableChannel，以获得客户端发送过来的数据。
    • 使用NIO中非阻塞IO编写服务器处理程序，有三个步骤
      • 向Selector对象注册感兴趣的事件
      • 从Selector中获取感兴趣的事件
      • 根据不同事件进行相应的处理

源码放在下一站👍

借鉴网址（Thanks Everyone🤞 ✌️ 🤟 🤘 👌）

左耳听风