# java-nio-demo

**Repository Path**: EricLoveMia/java-nio-demo

## Basic Information

- **Project Name**: java-nio-demo
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2023-11-15
- **Last Updated**: 2023-11-15

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# java-nio-demo

## nio介绍
    
代码对应教程-文章来源 http://www.52im.net/thread-2640-1-1.html 

### 为什么要使用 NIO?
       NIO 的创建目的是为了让 Java 程序员可以实现高速 I/O 而无需编写自定义的本机代码。NIO 将最耗时的 I/O 操作(即填充和提取缓冲区)转移回操作系统，  </br> 
    因而可以极大地提高速度。

### 流与块的比较
        原来的 I/O 库(在 java.io.*中) 与 NIO 最重要的区别是数据打包和传输的方式。正如前面提到的，原来的 I/O 以流的方式处理数据，而 NIO 以块的方式处理数据。 </br>
        面向流 的 I/O 系统一次一个字节地处理数据。一个输入流产生一个字节的数据，一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器， </br> 
    便每个过滤器只负责单个复杂处理机制的一部分，这样也是相对简单的。不利的一面是，面向流的 I/O 通常相当慢。 </br>
        一个 面向块 的 I/O 系统以块的形式处理数据。每一个操作都在一步中产生或者消费一个数据块。按块处理数据比按(流式的)字节处理数据要快得多。但是面向块的 I/O </br>
    缺少一些面向流的 I/O 所具有的优雅性和简单性。</br>

### 通道和缓冲区
#### 概述

    1、通道和缓冲区是NIO中的核心对象，几乎在每一个 I/O 操作中都要使用它们。
    2、通道是对原 I/O 包中的流的模拟。到任何目的地(或来自任何地方)的所有数据都必须通过一个 Channel 对象。一个 Buffer 实质上是一个容器对象。
    发送给一个通道的所有对象都必须首先放到缓冲区中；同样地，从通道中读取的任何数据都要读到缓冲区中。

#### 什么是缓冲区？

    1、Buffer 是一个对象， 它包含一些要写入或者刚读出的数据。 在 NIO 中加入 Buffer 对象，体现了新库与原 I/O 的一个重要区别。
    在面向流的 I/O 中，您将数据直接写入或者将数据直接读到 Stream 对象中。在 NIO 库中，所有数据都是用缓冲区处理的。在读取数据时，
    它是直接读到缓冲区中的。在写入数据时，它是写入到缓冲区中的。任何时候访问 NIO 中的数据，您都是将它放到缓冲区中。

    2、缓冲区实质上是一个数组。通常它是一个字节数组，但是也可以使用其他种类的数组。但是一个缓冲区不 仅仅 是一个数组。
    缓冲区提供了对数据的结构化访问，而且还可以跟踪系统的读/写进程。

#### 缓冲区类型

    最常用的缓冲区类型是 ByteBuffer。一个 ByteBuffer 可以在其底层字节数组上进行 get/set 操作(即字节的获取和设置)。

    ByteBuffer 不是 NIO 中唯一的缓冲区类型。

    事实上，对于每一种基本 Java 类型都有一种缓冲区类型：

    ByteBuffer
    CharBuffer
    ShortBuffer
    IntBuffer
    LongBuffer
    FloatBuffer
    DoubleBuffer

    每一个 Buffer 类都是 Buffer 接口的一个实例。 除了 ByteBuffer，每一个 Buffer 类都有完全一样的操作，只是它们所处理的数据类型不一样。
    因为大多数标准 I/O 操作都使用 ByteBuffer，所以它具有所有共享的缓冲区操作以及一些特有的操作。

    现在您可以花一点时间运行 UseFloatBuffer.java，它包含了类型化的缓冲区的一个应用例子。

#### 什么是通道？

    Channel是一个对象，可以通过它读取和写入数据。拿 NIO 与原来的 I/O 做个比较，通道就像是流。
    正如前面提到的，所有数据都通过 Buffer 对象来处理。您永远不会将字节直接写入通道中，相反，
    您是将数据写入包含一个或者多个字节的缓冲区。同样，您不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

#### 通道类型

    通道与流的不同之处在于通道是双向的。而流只是在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)， 而通道可以用于读、写或者同时用于读写。
    因为它们是双向的，所以通道可以比流更好地反映底层操作系统的真实情况。特别是在 UNIX 模型中，底层操作系统通道是双向的。


## NIO 中的读和写

### 概述

    读和写是 I/O 的基本过程。从一个通道中读取很简单：只需创建一个缓冲区，然后让通道将数据读到这个缓冲区中。
    写入也相当简单：创建一个缓冲区，用数据填充它，然后让通道用这些数据来执行写入操作。

### 从文件中读取

    在我们第一个练习中，我们将从一个文件中读取一些数据。如果使用原来的 I/O，那么我们只需创建一个 FileInputStream 并从它那里读取。
    而在 NIO 中，情况稍有不同：我们首先从 FileInputStream 获取一个 Channel 对象，然后使用这个通道来读取数据。
    在 NIO 系统中，任何时候执行一个读操作，您都是从通道中读取，但是您不是 直接 从通道读取。因为所有数据最终都驻留在缓冲区中，所以您是从通道读到缓冲区中。

    因此读取文件涉及三个步骤：(1) 从 FileInputStream 获取 Channel，(2) 创建 Buffer，(3) 将数据从 Channel 读到 Buffer 中。
    
    第一步是获取通道。我们从 FileInputStream 获取通道：
    FileInputStream fin = new FileInputStream( "readandshow.txt" );
    FileChannel fc = fin.getChannel();

    下一步是创建缓冲区：
    ByteBuffer buffer = ByteBuffer.allocate( 1024 );

    最后，需要将数据从通道读到缓冲区中，如下所示：
    fc.read( buffer );
    
例子:[ReadAndShow.java](src%2Fmain%2Fjava%2Fcom%2Floveprogrammer%2Fnio%2FReadAndShow.java)

### 写入文件

    在 NIO 中写入文件类似于从文件中读取。首先从 FileOutputStream 获取一个通道：
    FileOutputStream fout = new FileOutputStream( "writesomebytes.txt" );

    FileChannel fc = fout.getChannel();

    下一步是创建一个缓冲区并在其中放入一些数据 - 在这里，数据将从一个名为 message 的数组中取出，这个数组包含字符串 "Some bytes" 的 ASCII 字节(本教程后面将会解释 buffer.flip() 和 buffer.put() 调用)。
    ByteBuffer buffer = ByteBuffer.allocate( 1024 );

    for (int ii=0; ii<message.length; ++ii) {
     buffer.put( message[ii] );
    }

    buffer.flip();

    最后一步是写入缓冲区中：
    fc.write( buffer );

    注意在这里同样不需要告诉通道要写入多数据。缓冲区的内部统计机制会跟踪它包含多少数据以及还有多少数据要写入。

例子：[CopyFile.java](src%2Fmain%2Fjava%2Fcom%2Floveprogrammer%2Fnio%2FCopyFile.java)


### 状态变量

    可以用三个值指定缓冲区在任意时刻的状态：

    position
    limit
    capacity

    这三个变量一起可以跟踪缓冲区的状态和它所包含的数据。我们将在下面的小节中详细分析每一个变量，还要介绍它们如何适应典型的读/写(输入/输出)进程。在这个例子中，我们假定要将数据从一个输入通道拷贝到一个输出通道。

#### Position

    您可以回想一下，缓冲区实际上就是美化了的数组。在从通道读取时，您将所读取的数据放到底层的数组中。 position 变量跟踪已经写了多少数据。更准确地说，它指定了下一个字节将放到数组的哪一个元素中。因此，如果您从通道中读三个字节到缓冲区中，那么缓冲区的 position 将会设置为3，指向数组中第四个元素。
    同样，在写入通道时，您是从缓冲区中获取数据。 position 值跟踪从缓冲区中获取了多少数据。更准确地说，它指定下一个字节来自数组的哪一个元素。因此如果从缓冲区写了5个字节到通道中，那么缓冲区的 position 将被设置为5，指向数组的第六个元素。

#### Limit

    limit 变量表明还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)。
    position 总是小于或者等于 limit。

#### Capacity

    缓冲区的 capacity 表明可以储存在缓冲区中的最大数据容量。实际上，它指定了底层数组的大小 ― 或者至少是指定了准许我们使用的底层数组的容量。
    limit 决不能大于 capacity。

### flip() 方法
    flip的意义就是翻转position和limit的值 

### clear() 方法
    Clear 做两种非常重要的事情：
    1）它将 limit 设置为与 capacity 相同；
    2）它设置 position 为 0

### get() 方法

    ByteBuffer 类中有四个 get() 方法：

    1）byte get();
    2）ByteBuffer get( byte dst[] );
    3）ByteBuffer get( byte dst[], int offset, int length );
    4）byte get( int index );

    第一个方法获取单个字节。第二和第三个方法将一组字节读到一个数组中。第四个方法从缓冲区中的特定位置获取字节。
    那些返回 ByteBuffer 的方法只是返回调用它们的缓冲区的 this 值。此外，我们认为前三个 get() 方法是相对的，而最后一个方法是绝对的。
    相对 意味着 get() 操作服从 limit 和 position 值 ― 更明确地说，字节是从当前 position 读取的，而 position 在 get 之后会增加。
    另一方面，一个绝对方法会忽略 limit 和 position 值，也不会影响它们。事实上，它完全绕过了缓冲区的统计方法。

### put()方法

    ByteBuffer 类中有五个 put() 方法：

    1）ByteBuffer put( byte b );
    2）ByteBuffer put( byte src[] );
    3）ByteBuffer put( byte src[], int offset, int length );
    4）ByteBuffer put( ByteBuffer src );
    5）ByteBuffer put( int index, byte b );

    第一个方法 写入（put） 单个字节。第二和第三个方法写入来自一个数组的一组字节。第四个方法将数据从一个给定的源 ByteBuffer 写入这个 ByteBuffer。第五个方法将字节写入缓冲区中特定的 位置 。那些返回 ByteBuffer 的方法只是返回调用它们的缓冲区的 this 值。
    与 get() 方法一样，我们将把 put() 方法划分为 相对 或者 绝对 的。前四个方法是相对的，而第五个方法是绝对的。

### 内存映射文件 I/O

    内存映射文件 I/O 是一种读和写文件数据的方法，它可以比常规的基于流或者基于通道的 I/O 快得多。
    内存映射文件 I/O 是通过使文件中的数据神奇般地出现为内存数组的内容来完成的。这其初听起来似乎不过就是将整个文件读到内存中，但是事实上并不是这样。一般来说，只有文件中实际读取或者写入的部分才会送入（或者 映射 ）到内存中。
    内存映射并不真的神奇或者多么不寻常。现代操作系统一般根据需要将文件的部分映射为内存的部分，从而实现文件系统。Java 内存映射机制不过是在底层操作系统中可以采用这种机制时，提供了对该机制的访问。
    尽管创建内存映射文件相当简单，但是向它写入可能是危险的。仅只是改变数组的单个元素这样的简单操作，就可能会直接修改磁盘上的文件。修改数据与将数据保存到磁盘是没有分开的。

### 将文件映射到内存
    
    了解内存映射的最好方法是使用例子。在下面的例子中，我们要将一个 FileChannel (它的全部或者部分)映射到内存中。为此我们将使用 FileChannel.map() 方法。
    下面代码行将文件的前 1024 个字节映射到内存中：
    MappedByteBuffer mbb = fc.map( FileChannel.MapMode.READ_WRITE, 0, 1024 );
    map() 方法返回一个 MappedByteBuffer，它是 ByteBuffer 的子类。因此，您可以像使用其他任何 ByteBuffer 一样使用新映射的缓冲区，操作系统会在需要时负责执行行映射。

## 分散和聚集
    分散/聚集 I/O 是使用多个而不是单个缓冲区来保存数据的读写方法。
    一个分散的读取就像一个常规通道读取，只不过它是将数据读到一个缓冲区数组中而不是读到单个缓冲区中。同样地，一个聚集写入是向缓冲区数组而不是向单个缓冲区写入数据。
    分散/聚集 I/O 对于将数据流划分为单独的部分很有用，这有助于实现复杂的数据格式。

### 分散/聚集 I/O

    通道可以有选择地实现两个新的接口： ScatteringByteChannel 和 GatheringByteChannel。
    一个 ScatteringByteChannel 是一个具有两个附加读方法的通道：
    long read( ByteBuffer[] dsts );
    long read( ByteBuffer[] dsts, int offset, int length );
    这些 long read() 方法很像标准的 read 方法，只不过它们不是取单个缓冲区而是取一个缓冲区数组。
    在 分散读取 中，通道依次填充每个缓冲区。填满一个缓冲区后，它就开始填充下一个。在某种意义上，缓冲区数组就像一个大缓冲区。

### 分散/聚集的应用

    分散/聚集 I/O 对于将数据划分为几个部分很有用。例如，您可能在编写一个使用消息对象的网络应用程序，每一个消息被划分为固定长度的头部和固定长度的正文。您可以创建一个刚好可以容纳头部的缓冲区和另一个刚好可以容难正文的缓冲区。当您将它们放入一个数组中并使用分散读取来向它们读入消息时，头部和正文将整齐地划分到这两个缓冲区中。
    我们从缓冲区所得到的方便性对于缓冲区数组同样有效。因为每一个缓冲区都跟踪自己还可以接受多少数据，所以分散读取会自动找到有空间接受数据的第一个缓冲区。在这个缓冲区填满后，它就会移动到下一个缓冲区。

### 聚集写入

    聚集写入 类似于分散读取，只不过是用来写入。它也有接受缓冲区数组的方法：
    long write( ByteBuffer[] srcs );
    long write( ByteBuffer[] srcs, int offset, int length );
    聚集写对于把一组单独的缓冲区中组成单个数据流很有用。为了与上面的消息例子保持一致，您可以使用聚集写入来自动将网络消息的各个部分组装为单个数据流，以便跨越网络传输消息。
    
例子：[UseScatterGather.java](src%2Fmain%2Fjava%2Fcom%2Floveprogrammer%2Fnio%2FUseScatterGather.java)

## 异步 I/O

    异步 I/O 是一种 没有阻塞地 读写数据的方法。通常，在代码进行 read() 调用时，代码会阻塞直至有可供读取的数据。同样， write() 调用将会阻塞直至数据能够写入。
    另一方面，异步 I/O 调用不会阻塞。相反，您将注册对特定 I/O 事件的兴趣 ― 可读的数据的到达、新的套接字连接，等等，而在发生这样的事件时，系统将会告诉您。
    异步 I/O 的一个优势在于，它允许您同时根据大量的输入和输出执行 I/O。同步程序常常要求助于轮询，或者创建许许多多的线程以处理大量的连接。使用异步 I/O，您可以监听任何数量的通道上的事件，不用轮询，也不用额外的线程。

例子：[MultiPortEcho.java](src%2Fmain%2Fjava%2Fcom%2Floveprogrammer%2Fnio%2FMultiPortEcho.java)

## 编码/解码

    要读和写文本，我们要分别使用 CharsetDecoder 和 CharsetEncoder。将它们称为 编码器 和 解码器 是有道理的。一个 字符 不再表示一个特定的位模式，而是表示字符系统中的一个实体。因此，由某个实际的位模式表示的字符必须以某种特定的 编码 来表示。
    CharsetDecoder 用于将逐位表示的一串字符转换为具体的 char 值。同样，一个 CharsetEncoder 用于将字符转换回位。
例子：[UseCharsets.java](src%2Fmain%2Fjava%2Fcom%2Floveprogrammer%2Fnio%2FUseCharsets.java)


# netty-demo