Java NIO简述

本文首先介绍NIO涉及到的相关概念，然后将介绍NIO的编程流程以及示例，最后简述NIO涉及的相关问题解答。

Java New IO(NIO)是从Java1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同，NIO支持面向缓冲区的、基于通道的IO操作。NIO将以更加高效的方式进行文件的读写操作。
主要涉及三个概念，我们先简单介绍：缓冲区（buffer），通道（channel），选择器（Selector）。

1、缓冲区（buffer）

缓冲区是包在一个对象中的基本数据类型数组，主要包括：CharBuffer，IntBuffer，DoubleBuffer，LongBuffer，FloatBuffer，ByteBuffer和MappedByteBuffer。而缓冲区主要有四个属性：

标记（mark）:备忘位置。调用 mark( )来设定 mark = postion。调用 reset( )设定 position =mark。标记在设定前是未定义的;

位置(position):下一个要被读或写的元素的索引。位置会自动由相应的 get( )和 put( )函数更新;

上界(limit):缓冲区的第一个不能被读或写的元素。或者说，缓冲区中现存元素的计数;

容量(capacity):缓冲区能够容纳的数据元素的最大数量。这一容量在缓冲区创建时被设定，并且永远不能被改变.

        在NIO中，数据是放入buffer中进行操作的，应用程序不能直接操作channel，而是通过buffer进行，它是NIO读写数据的中转池。缓冲区不仅仅是个数组，它提供对数据的结构化访问，还可以跟踪系统的读写进程。

    buffer读写数据的四个步骤：

1. 写入数据到buffer中；

2. 调用flip( )方法

3. 从buffer中读取数据；

4. 调用clear( )或compact( )方法。

       当向 Buffer 写入数据时，Buffer 会记录下写了多少数据。一旦要读取数据，需要通过 flip() 方法将 Buffer 从写模式切换到读模式。在读模式下，可以读取之前写入到 Buffer 的所有数据。一旦读完了所有的数据，就需要清空缓冲区，让它可以再次被写入。有两种方式能清空缓冲区：调用 clear() 或 compact() 方法。clear() 方法会清空整个缓冲区。compact() 方法只会清除已经读过的数据。任何未读的数据都被移到缓冲区的起始处，新写入的数据将放到缓冲区未读数据的后面。

2、通道（channel）

      通道（Channel）是 java.nio 的第二个主要创新。它们既不是一个扩展也不是一项增强，而是全新、极好的 Java I/O 示例，提供与 I/O 服务的直接连接。Channel 用于在字节缓冲区和位于通道另一侧的实体（通常是一个文件或套接字）之间有效地传输数据。从顶层的 Channel 接口可以发现，对所有通道来说只有两种共同的操作：检查一个通道是否打开（IsOpen()）和关闭一个打开的通道（close()），而更多有趣的操作则在其子类中。

    实际上，通道相当于一个对象，可以通过它读写数据，相当于IO流，区别在于：

1. IO流是单向的，而通道是双向的；

2. 通道可以进行异步的读写；

3. 对channel的读写必须经过缓冲区。

在Java中通道一般有四种类型： FileChannel：从文件读取数据；ServerSocketChannel：监听TCP连接；

SocketChannel：读取TCP网络协议数据；DataGramChannel：读写UDP网络协议数据。

3、选择器（Selector）

    选择器提供选择执行已经就绪的任务的能力，这使得多元I/O成为可能，就绪选择和多元执行使得单线程能够有效率的同时管理多个I/O通道（channels），简单言之就是selector充当一个监视者，需要将之前创建的一个或多个可选择的通道注册到选择器对象中。

选择器主要有三个属性：

选择器（Selector）

选择器类管理着一个被注册的通道集合的信息和它们的就绪状态。通道是和选择器一起被注册的,并且使用选择器来更新通道的就绪状态。当这么做的时候,可以选择将被激发的线程挂起,直到有就绪的的通道。

可选择通道(SelectableChannel)

SelectableChannel 可以被注册到 Selector 对象上,同时可以指定对那个选择器而言,那种操作是感兴趣的。一个通道可以被注册到多个选择器上,但对每个选择器而言只能被注册一次。

选择键(SelectionKey)

选择键封装了特定的通道与特定的选择器的注册关系。选择键对象被SelectableChannel.register( ) 返回并提供一个表示这种注册关系的标记。选择键包含了两个比特集(以整数的形式进行编码),指示了该注册关系所关心的通道操作,以及通道已经准备好的操作。

4、NIO编程流程及示例

Server：

1、先创建ServerSocketChannel实例、并且绑定端口;

2、创建selector实例;

3、将ServerSocketChannel实例注册到选择器上，并监听accept事件;

4、有事件发生（accept）,就获取客户端的socketChannel的连接，将连接实例注册到选择器上;

5、（IO操作）通过selector监听读事件，就进行相应的读事件，写事件类似，也需要监听--》Buffer;

6、关闭ServerSocketChannel实例;

Client:

1、创建SocketChannel实例;

2、创建selector选择器;

3、连接服务器;

4、将SocketChannel注册到selector选择器;

5、直接发送数据，通过selector选择器监听读事件;

6、关闭SocketChannel实例.

示例：

public class NIOServer {
    private static final int DEFAULT_PORT = 1234;
    public static void main(String[] args) throws IOException {
        //创建ServerSocketChannel实例
        ServerSocketChannel ssc = ServerSocketChannel.open();
        //绑定端口号
        ssc.bind(new InetSocketAddress(DEFAULT_PORT));
        System.out.println("服务端启动");
        //创建Selector实例
        Selector selector = Selector.open();
        //将ServerSocketChannel实例设为非阻塞（false）
        ssc.configureBlocking(false);
        //将ServerSocketChannel实例注册到selector上，并对accept事件进行监听
        ssc.register(selector,SelectionKey.OP_ACCEPT);
        //选择器进行阻塞，直到监听事件发生才返回
        while(selector.select() > 0){
            Iterator<SelectionKey> itr = selector.selectedKeys().iterator();
            while(itr.hasNext()){
                SelectionKey key = itr.next();
                itr.remove();
                //处理accept事件
                if (key.isValid() && key.isAcceptable()){
                    ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();
                    //接收新用户的连接
                    SocketChannel sc = serverSocketChannel.accept();
                    //将用户设置为非阻塞事件
                    sc.configureBlocking(false);
                    //将socketChannel实例注册到selector上
                    sc.register(selector,SelectionKey.OP_READ);
                }
                //处理读事件
                if (key.isValid() && key.isReadable()){
                    SocketChannel socketChannel = (SocketChannel)key.channel();
                    //创建缓冲区
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    //将数据读到缓冲区中
                    socketChannel.read(buffer);
                    //翻转
                    buffer.flip();
                    byte[] bytes = new byte[buffer.remaining()];
                    //将数据读到byte中
                   buffer.get(bytes);
                   String msg = new String(bytes);
                    System.out.println("客户端发送消息"+msg);
                    key.cancel();
                    //关闭用户连接
                    socketChannel.close();
                }
                //处理写事件

            }
        }
        System.out.println("服务端结束");
        //关闭
        ssc.close();
        selector.close();
    }
}




public class NIOClient {
    private static final int DEFAULT_PORT = 1234;
    public static void main(String[] args) throws IOException {
        //创建SocketChannel实例
        SocketChannel socketChannel = SocketChannel.open();
        //创建选择器实例
        Selector selector = Selector.open();
        //将SocketChannel设为非阻塞
        socketChannel.configureBlocking(false);
        //将connect设为非阻塞，则无论connect是否发生都会立即返回
        if(!socketChannel.connect(new InetSocketAddress("127.0.0.1",DEFAULT_PORT))){
            //服务端还未连接上，对connect事件进行监听，将socketChannel注册到选择器上
            socketChannel.register(selector,SelectionKey.OP_CONNECT);
        }
        int num;
        while((num = selector.select(1000))>0){
            System.out.println("select返回"+num);
            //获取注册到选择器上的事件
            Set<SelectionKey> selectionKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = selectionKeys.iterator();
            while(iterator.hasNext()){
                SelectionKey key = iterator.next();
                iterator.remove();
                //可连接事件完成
                if(key.isValid() && key.isConnectable()){
                    SocketChannel sc = (SocketChannel) key.channel();
                    key.cancel();
                    //若连接未完成，结束该用户连接
                    if(!sc.finishConnect()){
                        System.exit(1);
                    }
                    //连接完成，创建发送数据的缓冲区
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    buffer.put("hello".getBytes());
                    buffer.flip();
                    //给服务端发消息
                    socketChannel.write(buffer);
                    System.out.println("给服务端发消息完成");
                }
            }
        }
        //关闭
        selector.close();
        socketChannel.close();
        System.out.println("客户端关闭");
    }
}

5、问题解决

IO与NIO的比较

面向流 VS 面向缓冲

Java I/O是面向流的， 每次从流（InputStream/OutputStream）中读一个或多个字节，直到读取完所有字节，它们没有被缓存在任何地方。另外，它不能前后移动流中的数据，如需前后移动处理，需要先将其缓存至一个缓冲区。

Java I/O是面向缓冲， 数据会被读取到一个缓冲区，需要时可以在缓冲区中前后移动处理，这增加了处理过程的灵活性。但与此同时在处理缓冲区前需要检查该缓冲区中是否包含有所需要处理的数据，并需要确保更多数据读入缓冲区时，不会覆盖缓冲区内尚未处理的数据。

阻塞 VS 非阻塞

Java IO的各种流是阻塞的。当某个线程调用read()或write()方法时，该线程被阻塞，直到有数据被读取到或者数据完全写入。阻塞期间该线程无法处理任何其它事情。

Java NIO非阻塞模式。读写请求并不会阻塞当前线程，在数据可读/写前当前线程可以继续做其它事情，所以一个单独的线程可以管理多个输入和输出通道。

选择器

Java NIO的选择器允许一个单独的线程同时监视多个通道，可以注册多个通道到同一个选择器上，然后使用一个单独的线程来“选择”已经就绪的通道。这种“选择”机制为一个单独线程管理多个通道提供了可能。

零拷贝

Java NIO中提供的FileChannel拥有transferTo和transferFrom两个方法，可直接把FileChannel中的数据拷贝到另外一个Channel，或者直接把另外一个Channel中的数据拷贝到FileChannel。该接口常被用于高效的网络/文件的数据传输和大文件拷贝。在操作系统支持的情况下，通过该方法传输数据并不需要将源数据从内核态拷贝到用户态，再从用户态拷贝到目标通道的内核态，同时也避免了两次用户态和内核态间的上下文切换，也即使用了“零拷贝”，所以其性能一般高于Java IO中提供的方法。

通道

NIO的一大创新就是通道，channel可以是双向的，而IO流是单向的。

6、小结

NIO的使用带来了很多好处：

• 事件驱动模型
• 避免多线程
• 单线程处理多任务
• 非阻塞I/O，I/O读写不再阻塞，而是返回0
• 基于block的传输，通常比基于流的传输更高效
• 更高级的IO函数，zero-copy
• IO多路复用大大提高了Java网络应用的可伸缩性和实用性

参考文章：http://ifeve.com/tag/nio/

https://tech.meituan.com/2016/11/04/nio.html