深入理解NIO

NIO(no-blocking I/O)

在oracle的官方文档中有明确的指出，java.io 和 java.nio 提供了丰富的API去管理一个应用的 I/O。功能包括 文件、设备的 I/O、对象的序列化、缓冲区管理、字符集的支持等等。同时最主要的NIO的特色就是在于：多路复用、非阻塞式IO、内存映射、文件锁。更多细节建议大家也可看官方文档I/O documentation

接下来就从不同的方面来介绍NIO

I/O 流

也可称之为数据序列 （A stream is a sequence of data）

I/O ? 或者输入/输出 ? 一个 I/O 流代表的是一个输入源和输出对象。流可以代表不同类型的源和目标。包括磁盘文件、设备、其他程序和内存数组等。流支持多种不同类型的数据，包括简单字节、原始数据类型、本地化字符和对象。一些流只是简单的用于传输数据。无论它们在内部如何工作，所有流都向使用它们的程序呈现相同的简单模型。也就是简单的读取和输入数据（如下图）。

为什么要使用NIO？

NIO 与原来 IO 有相同的作用和目的，但是它使用的方式不同：采用的是块 I/O。NIO创建的目的就是为了让Java程序员可以实现高速 I/O 而无需编写自定义的本机代码。NIO 将最耗时的I/O操作（即填充和提取缓冲区）转移回操作系统，因而极大地提高速度。

流与块的比较

面向流 的 I/O 系统一次一个字节地处理数据。一个输入流产生一个字节的数据，一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器，以便每个过滤器只负责单个复杂处理机制的一部分，这样也是相对简单的。不利的一面是，面向流的 I/O 通常相当慢。

一个面向块 的 I/O 系统以块的形式处理数据。每一个操作都在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多。但是面向块的 I/O 缺少一些面向流的 I/O 所具有的优雅性和简单性。

NIO中的核心概念

通道、缓冲区、选择器

通道和缓冲区是 NIO 的核心对象。简单来说，通道就是模拟流而缓冲区本质上就是数组，但是它又只是数组。就是存储要在通道中传输的数据（包含输入流读取、输出流写入），类似于一个容器。

缓冲区

Buffer 是一个对象，它包含了写入或者刚读出的数据。在 NIO 中加入 Buffer 对象也是为了与原 I/O的一个重要区别。在 I/O 中，会将数据直接操作到 Stream对象中。
在 NIO 体系中，任何时候数据都是通过缓冲区进行处理的，包括读取数据、写入数据。
每一种Java基本类型都有对应的缓冲区

• ByteBuffer
• CharBuffer
• ShortBuffer
• IntBuffer
• LongBuffer
• FloatBuffer
• DoubleBuffer

与数组不同的地方

通常情况下，缓冲区是一个字节数组，但是也可以使用其他类型的数组
与普通数组不同的地方在于，缓冲区提供了对数据的结构化访问，是可以跟踪当前程序的读/写进度

缓冲区内部维护了几个不同的私有状态变量来跟踪读/写进度

    // Invariants: mark <= position <= limit <= capacity
    private int mark = -1; // 表示当前缓冲区的标记
    private int position = 0; // 当前读取/写入的位置
    private int limit; // 当前读取/写入的数据最大限制
    private int capacity; // 数组的最大容量

一个简单的ByteBuffer的声明

ByteBuffer byteBuffer = ByteBuffer.allocate(1024); // 通过allocate return new HeapByteBuffer(capacity, capacity);
ByteBuffer byteBufferWrap = ByteBuffer.wrap(new byte[1024]); // 通过wrap 包装数组 return new HeapByteBuffer(array, offset, length);

通道

Channel是一个对象，可以通过它读取和写入数据。与 I/O 相比，通道就像是流。
因为所有的数据都是通过 Buffer 处理的。永远不会将字节直接写入通道中，相反，是将数据写入包含一个或者多个字节的缓冲区。同样，也不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

通道类型

通道与流的不同点就在于通道是双向的，而流是在一个方向上进行移动（一个流必须是InputStream 或 OutputStream 的子类），而通道是可以读、写或者同时用于读写。
将二者结合起来实现一个简单的 FileCopy

        FileChannel inputChannel = new FileInputStream("C:\\Users\\Administrator\\Desktop\\REQ-5932\\table_sqlserver.sql").getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        FileChannel outputChannel = new FileOutputStream("C:\\Users\\Administrator\\Desktop\\1.sql").getChannel();
        while (true) {
            byteBuffer.clear(); // 将position置为0，limit置为capacity
            int read = inputChannel.read(byteBuffer);
            if (read == -1) {
                break;
            }
            byteBuffer.flip(); //执行此方法之后会将limit的值等于position，并将position置为0
            outputChannel.write(byteBuffer);
        }
        inputChannel.close();
        outputChannel.close();

首先创建一个 byteBuffer ，然后从源文件中将数据读到这个缓冲区中，然后将缓冲区写入目标文件。这个程序不断重复 ― 读、写、读、写 ― 直到源文件结束。
clear()方法重设缓冲区，使它可以接受读入的数据。
flip()方法让缓冲区可以将新读入的数据写入另一个通道。

缓存区的分片

slice()
方法根据现有的缓冲区创建一种子缓冲区。也就是说，它创建一个新的缓冲区，新缓冲区与原来的缓冲区的一部分共享数据。

ByteBuffer buffer = ByteBuffer.allocate( 10 );

然后使用数据来填充这个缓冲区，在第 n 个槽中放入数字 n：

for (int i = 0; i < buffer.capacity(); ++i) { buffer.put( (byte)i ); }

现在我们对这个缓冲区分片，以创建一个包含槽 3 到槽 6 的子缓冲区。在某种意义上，子缓冲区就像原来的缓冲区中的一个窗口。

窗口的起始和结束位置通过设置 position和 limit值来指定，然后调用 Buffer 的 slice()方法：

buffer.position( 3 ); buffer.limit( 7 ); ByteBuffer slice = buffer.slice();

通过以上操作就完成了对一个缓存区的分片。子缓存区与父缓存区共享一个数组。我们单独对子缓存区进行操作
我们遍历子缓冲区，将每一个元素乘以 11 来改变它。例如，5 会变成 55。

for (int i = 0; i < slice.capacity(); ++i) 
{ byte b = slice.get( i ); b *= 11; slice.put( i, b ); }

最后，再看一下原缓冲区中的内容：

buffer.position( 0 ); 
buffer.limit( buffer.capacity() ); 
while ( buffer.remaining() > 0) { System.out.println( buffer.get() ); }

结果表明只有在子缓冲区窗口中的元素被改变了：

0 12 33 44 55 66 7 8 9

只读缓存区

只读缓冲区非常简单 ― 可以读取它们，但是不能向它们写入。可以通过调用缓冲区的 asReadOnlyBuffer()方法，将任何常规缓冲区转换为只读缓冲区，这个方法返回一个与原缓冲区完全相同的缓冲区(并与其共享数据)，只不过它是只读的。

只读缓冲区对于保护数据很有用。在将缓冲区传递给某个对象的方法时，您无法知道这个方法是否会修改缓冲区中的数据。创建一个只读的缓冲区可以 *保证 *该缓冲区不会被修改.

不能将只读的缓冲区转换为可写的缓冲区。

直接缓存区（DirectBuffer）

直接和间接缓冲区
另一种有用的 ByteBuffer是直接缓冲区。 *直接缓冲区 *是为加快 I/O 速度，而以一种特殊的方式分配其内存的缓冲区。官方文档是这样描述直接缓存区的：

给定一个直接字节缓冲区，Java 虚拟机将尽最大努力直接对它执行本机 I/O 操作。也就是说，它会在每一次调用底层操作系统的本机 I/O 操作之前(或之后)，尝试避免将缓冲区的内容拷贝到一个中间缓冲区中(或者从一个中间缓冲区中拷贝数据)。

直接缓存区的get或者put操作都是通过unsafe类进行直接调用的，采用底层的操作系统去执行。

    // Cached unsafe-access object
    protected static final Unsafe unsafe = Bits.unsafe();

    // Cached array base offset
    private static final long arrayBaseOffset = (long)unsafe.arrayBaseOffset(byte[].class);
    
    public ByteBuffer put(byte x) {
        unsafe.putByte(ix(nextPutIndex()), ((x)));
        return this;
    }

    public byte get(int i) {
       return ((unsafe.getByte(ix(checkIndex(i)))));
    }

内存映射文件 I/O

也是属于 NIO 方式的一种。内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。

内存映射文件 I/O 是通过使文件中的数据神奇般地出现为内存数组的内容来完成的。这其初听起来似乎不过就是将整个文件读到内存中，但是事实上并不是这样。一般来说，只有文件中实际读取或者写入的部分才会送入（或者 映射 ）到内存中。

内存映射并不真的神奇或者多么不寻常。现代操作系统一般根据需要将文件的部分映射为内存的部分，从而实现文件系统。Java 内存映射机制不过是在底层操作系统中可以采用这种机制时，提供了对该机制的访问。 尽管创建内存映射文件相当简单，但是向它写入可能是危险的。仅只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。
实现内存映射Demo

FileChannel inputChannel = new FileInputStream("C:\\Users\\Administrator\\Desktop\\REQ-5932\\table_sqlserver.sql").getChannel();
MappedByteBuffer mbb = inputChannel.map( FileChannel.MapMode.READ_WRITE, 0, 1024 );

map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，您可以像使用其他任何 ByteBuffer一样使用新映射的缓冲区，操作系统会在需要时负责执行映射。

文件锁

文件锁实质上也是一种共享和排他锁的一种体现。尝试获取锁就是获取的一个排他锁

RandomAccessFile file = new RandomAccessFile("C:\\Users\\Administrator\\Desktop\\REQ-5932\\table_sqlserver.sql", "rw");
FileChannel channel = file.getChannel();
channel.tryLock();

在拥有锁之后，您可以执行需要的任何敏感操作，然后再释放锁：

lock.release();

在释放锁后，尝试获得锁的其他任何程序都有机会获得它。

Selectors

异步 I/O 中的核心对象名为 Selector。Selector 就是您注册对各种 I/O 事件的兴趣的地方，而且当那些事件发生时，就是这个对象告诉您所发生的事件。
博主会后续更新关于 Selectors 的内容