JAVA NIO知识点总结(1)——NIO缓冲区的存取操作原理及方法

2019独角兽企业重金招聘Python工程师标准>>>

NIO概述

Java NIO（ New IO） 是从Java 1.4版本开始引入的一个新的IO API，可以替代标准的Java IO API。

NIO与原来的IO有同样的作用和目的，但是使用的方式完全不同， NIO支持面向缓冲区的、基于
通道的IO操作。 NIO将以更加高效的方式进行文件的读写操作。

其实，从NIO更贴合的名字是Non-Blocking IO，非阻塞IO。

在如今，有两点造就了NIO越来越重要：一是jdk1.7对NIO进行了大幅改进，有些人干脆称之为NIO2；二是如今互联网对高并发的日益迫切的需求。这两点使得一个早在1.4被推出但不温不火的技术，在现今变得不可忽视。NIO从jdk 1.4 开始就有了，随着并发需求越来越大，特别是jdk1.7对NIO进行了改进之后，使得其已经成为java程序员的必备技术。

NIO与IO的区别

由面向存取数据的载体、是否阻塞等可以分为以下三点不同：

什么是面向流？什么是面向缓冲区？我们简单个说明，缓冲区等概念我们放到后面说。

面向流：

数据像水流一样传输，并且，要么输入要么输出，流是单向的。流中都是水（数据），随波逐流传递给目的地。

面向缓冲区：

NIO会在程序与文件（磁盘、网络）之间建立一个通道用于连接，然后通过缓冲区进行数据存取，通过通道进行连接传递。

打个比方来说，通道相当于铁轨。铁轨连接两个地点，但是铁轨不能放货物（数据），货物需要放到火车（缓冲区）里。缓冲区相当于火车，火车装载（存入）和卸载（取出）货物（数据），火车在通道上来回传递运输。

传输数据的是缓冲区，所以相当于火车，并且是双向的。

总结：通道主要负责连接，通道本身没数据；而数据的存储由缓冲区完成。

 

阻塞IO和非阻塞IO、选择器主要是针对网络编程而言的。

（本文出自oschina博主happyBKs的文章：https://my.oschina.net/happyBKs/blog/1591135）

缓冲区的数据存取

通道（ Channel）与缓冲区（ Buffer）

Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。
简而言之， Channel 负责传输、连接， Buffer 负责数据存储、操作

缓冲区（ Buffer）

 缓冲区（ Buffer） ：一个用于特定基本数据类型的容器。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类。
 Java NIO 中的 Buffer 主要用于与 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。
Buffer 就像一个数组，可以保存多个相同类型的数据。根据数据类型不同(boolean 除外) ，有以下 Buffer 七个常用子类：

 ByteBuffer
 CharBuffer
 ShortBuffer
 IntBuffer
 LongBuffer
 FloatBuffer
 DoubleBuffer

上述 Buffer 类 他们都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。都是通过allocate方法获取一个 Buffer对象：

static XxxBuffer allocate(int capacity) : 创建一个容量为 capacity 的 XxxBuffer 对象

ByteBuffer继承自父类Buffer

public abstract class ByteBuffer
    extends Buffer
    implements Comparable<ByteBuffer>
{

    // These fields are declared here rather than in Heap-X-Buffer in order to
    // reduce the number of virtual method invocations needed to access these
    // values, which is especially costly when coding small buffers.
    //
    final byte[] hb;                  // Non-null only for heap buffers
    final int offset;
    boolean isReadOnly;                 // Valid only for heap buffers

Buffer是7种缓冲区的父类：

Buffer中的四个核心属性，以及他们之间的关系：mark <= position <= limit <= capacity

public abstract class Buffer {

    /**
     * The characteristics of Spliterators that traverse and split elements
     * maintained in Buffers.
     */
    static final int SPLITERATOR_CHARACTERISTICS =
        Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;

    // Invariants: mark <= position <= limit <= capacity
    private int mark = -1;
    private int position = 0;
    private int limit;
    private int capacity;

整个Buffer父类里实现的都有有关这几个核心数据行的field和method。而有关存取的操作都封装在继承他的7个对应具体类型的缓冲区子类里。父类Buffer中甚至没有对put和get这些读写的基本方法做抽象封装。所以，职能分工已经很明确了，在操作存取数据时，用的是具体类型的子类方法，而不能通过父类Buffer的引用调用接口。有点啰嗦，呵呵。
那么下面我们来看看这几个核心属性都是什么东东？乍一看，都是整型数，似乎与大小、位置先关。那么我们下面来具体看看。

 

 

Buffer 中的重要概念：

 容量 (capacity) ： 表示 Buffer 最大数据容量，缓冲区容量不能为负，并且创建后不能更改。

                        缓冲区其实就是数据组，因为是数组，所以数据容量一旦固定就不能修改了。花丛去的容                           量capacity也是这样，一旦确定不能修改。

 限制 (limit)： 第一个不应该读取或写入的数据的索引，即位于 limit 后的数据不可读写。缓冲区的限制不能为负，并且不能大于其容量。

 位置 (position)： 下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制

 标记 (mark)与重置 (reset)： 标记是一个索引，通过 Buffer 中的 mark() 方法指定 Buffer 中一个特定的 position，之后可以通过调用 reset() 方法恢复到这个 position。

 标记、 位置、 限制、 容量遵守以下不变式： 0 <= mark <= position <= limit <= capacity

注意：mark初始化为-1，表示没有标记过

 

 

那么这四个核心属性与缓冲区的存取操作是什么关系呢？如何来协作完成NIO缓冲区的读取呢？

当我们用XxxBuffer申请allocate(int)了一个缓冲区后，我们得到了一个capacity为指定参数的大小的数组缓冲区。当前我们什么都没做，position当然保持在初始0的位置，因为初始状态没有切换到读模式，没有什么需要标记其后不能读的，写只要不超过capacity就可以，所以limit放在最后，与capacity值一样。

当我们put()写入5个数值之后，position变为5（0到4已经写了数，若要继续写需要从5开始）。因为没有切换到读模式，所以没有什么需要声明其后不能读，写只要不超过capacity就可以，所以limit放在最后，与capacity值一样。

之后，当我们需要读取我们刚才写入缓冲区的数据时，首先需要做的是调用缓冲区的flip()方法，将缓冲区切换到读模式。切换到读模式之后，我们要做的是将刚才的写入的5个数据读取出来，很自然地，postion会变回0，因为0是写入的起始位置；因为刚才只写入了5个，因此数据只写到0-4，所以从第5个开始之后的不能被读取，所以limit变成5，限定5开始之后的缓冲区空间不能够被读取。

读的过程也是一样，postion会随着你读了几个，变化位置。如果调用了rewind()准备重读，那么position一定变回为0。如果读到当中的某个位置我们mark()了，这个标记的postion值会被缓冲区的核心属性mark记录下来，等到后来reset()的时候，mark属性记录的值会赋给position属性，用于回到刚才mark标记的位置用于重读。

这里我就不给图了，聪明如你，一定能够自行脑补：）。关于rewind()、reset()等的方法放在下面细说。

 

我们先来看看基本读写中的put和get方法。

我们可以看到put的方法有很多种，我们先只看与byte类型相关的put的重载方法：有put一个字节，有put一个byte数组的，有put另一个缓冲区的；有指定在缓冲区特定位置写入（覆盖）一个byte的，还有指定在目标缓冲区第offset位置开始依次写入一个byte数组中各个元素特定length个的。

切换到读模式之后，get方法也是一大坨。基本与byte数组读写的那些设计思路大同小异，你猜也应该知道什么时候该用哪个。

这里罗列几个常用的：

Buffer 所有子类提供了两个用于数据操作的方法： get()与 put() 方法

获取 Buffer 中的数据
get() ：读取单个字节
get(byte[] dst)：批量读取多个字节到 dst 中
get(int index)：读取指定索引位置的字节(不会移动 position)

放入数据到 Buffer 中
put(byte b)：将给定单个字节写入缓冲区的当前位置
put(byte[] src)：将 src 中的字节写入缓冲区的当前位置
put(int index, byte b)：将指定字节写入缓冲区的索引位置(不会移动 position)
 

这里需要注意的是，flip()切换到读取数据的模式。调用flip()切到读模式后，position归0，limit变为刚才写模式下的position的位置值。

我把读写的基本操作和说明以一个例子来说明:

package com.happybks.nio.nio;

import java.nio.ByteBuffer;

import org.junit.Test;

/**
 * 一、缓冲区（Buffer）：在java NIO中负责数据的存取。缓冲区就是数据。用于存储不同数据类型的数据
 * 
 * 跟局数据类型的不同（boolean除外，其他7种基本类型全有），提供相应类型的缓冲区：
 * ByteBuffer
 * CharBuffer
 * ShortBuffer
 * IntBuffer
 * LongBuffer
 * FloatBuffer
 * DoubleBuffer
 *  
 * 上述缓冲区的管理方式几乎一致，通过allocate()获取缓冲区
 * 最常用的是ByteBuffer，因为无论磁盘还是网络传输的都是Byte。
 * 
 * 有了缓冲区，接下来要往缓冲区存取数据
 * 
 * 二、缓冲区存取数据的两个核心方法：
 * put()：存入数据到缓冲区中
 * get()：获取缓冲区中的数据
 * 
 * 要想对缓冲区的数据进行正确的存取的话，必须姚先了解几个缓冲区的核心属性
 * 
 * 
 * 三、缓冲区中的四个核心属性：
 * capacity：容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。（因为缓冲区就是数组，数组大小不可改变）
 * limit：界限，表示缓冲区中可以操作数据的大小。（limit后面的数据不能进行读写）
 * position：位置，表示缓冲区正在操作数据的位置。
 * 
 * position <= limit <= capacity
 * 
 * 
 * mark：标记，表示记录当前position的位置。可以用过reset()恢复到mark的位置。
 * 
 * 0 <= mark <= position <= limit <= capacity
 * 
 * mark初始化为-1，表示没有标记过
 * 
 * 
 * @author HappyBks
 *
 */
public class TestBuffer {

	
	@Test
	public void test1(){
		//1、分配一个是指定大小的缓冲区
		ByteBuffer buf=ByteBuffer.allocate(1024);//指定缓冲区大小capacity为1024
		printBufferStatus(buf, "allocate()");
		
		//2、利用put()方法存入数据到缓冲区中
		final String dataStr="abcde";
		buf.put(dataStr.getBytes());
		printBufferStatus(buf, "put()");
		
		
		//3、切换读取数据模式
		buf.flip();
		printBufferStatus(buf, "flip()");
		
		//4、利用get()读取缓冲区中的数据
		byte[] dst=new byte[buf.limit()];
		buf.get(dst);
		System.out.println(new String(dst, 0 , dst.length));
		printBufferStatus(buf, "get()");
		
		
		//5、调用rewind()，恢复读模式到读之前的初始状态，用于可重复再读一次
		buf.rewind();
		printBufferStatus(buf, "rewind()");
		
		//6、clear()清空缓冲区，回到allocate()申请缓冲区的最初状态。
		//但是请注意，这个恢复到最初状态，指定是buffer的几个核心属性恢复到最初状态，
		//里面的数据依然还在，只不过这些数据处于“被遗忘”状态。
		//所谓被遗忘状态，是指buffer的几个指针都恢复到了初始位置，里面有几个数据，从哪读到哪，已经都不知道了。
		buf.clear();
		printBufferStatus(buf, "clear()");
		//尝试读取被clear()清空之后的缓冲区，数据依然在。（因为clear之后，我们无法之后原来有几个数据，所以读一个）
		System.out.println("clear()之后试着get()一个byte: "+(char)buf.get());
		
	}

	private void printBufferStatus(ByteBuffer buf, String info) {
		System.out.println("---------"+info+"----------");
		System.out.println("position: "+buf.position());
		System.out.println("limit: "+buf.limit());
		System.out.println("capacity: "+buf.capacity());
		System.out.println();
	}
	
	
	@Test
	public void test2(){
		final String dataStr="abcde";
		ByteBuffer buf=ByteBuffer.allocate(1024);
		buf.put(dataStr.getBytes());
		buf.flip();
		byte[] dst=new byte[buf.limit()];
		buf.get(dst, 0, 2);
		System.out.println("get(dst, 0, 2): "+new String(dst, 0, 2));
		System.out.println("get(dst, 0, 2) position: "+buf.position());
		
		//mark()：标记
		buf.mark();
		System.out.println("mark() position: "+buf.position());

		
		buf.get(dst, 2, 2);
		System.out.println("get(dst, 2, 2): "+new String(dst, 2, 2));
		System.out.println("get(dst, 2, 2) position: "+buf.position());
		
		//reset()：恢复到mark的位置
		buf.reset();
		System.out.println("reset() position: "+buf.position());

		//判断缓冲区中是否还有剩余数据
		if(buf.hasRemaining()){
			//获取缓冲区中农剩余的可以操作的数据量
			System.out.println("buf.remaining(): "+buf.remaining());
		}
		
	}
}

第一个例子演示了NIO的Byte缓冲区（其他数据类型的缓冲区操作方式大同小异）申请、写入、切换读模式、读取、可重复读、清空几个基本操作的使用方法，以及在这每个操作阶段缓冲区几个核心属性capacity、limit、position的变化。

第二个例子演示了读取时，如何标记特定位置、之后重置回到改位置重新读取、以及判断读取是否还有剩余、获知还剩多少未读的方法，以及每个操作阶段缓冲区几个核心属性position的变化。

打印结果如下：

test1()运行结果：

---------allocate()----------
position: 0
limit: 1024
capacity: 1024

---------put()----------
position: 5
limit: 1024
capacity: 1024

---------flip()----------
position: 0
limit: 5
capacity: 1024

abcde
---------get()----------
position: 5
limit: 5
capacity: 1024

---------rewind()----------
position: 0
limit: 5
capacity: 1024

---------clear()----------
position: 0
limit: 1024
capacity: 1024

clear()之后试着get()一个byte: a

test2()运行结果：

get(dst, 0, 2): ab
get(dst, 0, 2) position: 2
mark() position: 2
get(dst, 2, 2): cd
get(dst, 2, 2) position: 4
reset() position: 2
buf.remaining(): 3

关于核心属性mark的值得变化嘛，不打印了，看看mark()和reset()这俩方法的实现就明白了：

    /**
     * Sets this buffer's mark at its position.
     *
     * @return  This buffer
     */
    public final Buffer mark() {
        mark = position;
        return this;
    }

    /**
     * Resets this buffer's position to the previously-marked position.
     *
     * <p> Invoking this method neither changes nor discards the mark's
     * value. </p>
     *
     * @return  This buffer
     *
     * @throws  InvalidMarkException
     *          If the mark has not been set
     */
    public final Buffer reset() {
        int m = mark;
        if (m < 0)
            throw new InvalidMarkException();
        position = m;
        return this;
    }

 

Buffer 的常用方法

方 法	描 述
Buffer clear()	清空缓冲区并返回对缓冲区的引用
Buffer flip()	将缓冲区的界限设置为当前位置，并将当前位置充值为 0
int capacity()	返回 Buffer 的 capacity 大小
boolean hasRemaining()	判断缓冲区中是否还有元素
int limit()	返回 Buffer 的界限(limit) 的位置
Buffer limit(int n)	将设置缓冲区界限为 n, 并返回一个具有新 limit 的缓冲区对象
Buffer mark()	对缓冲区设置标记
int position()	返回缓冲区的当前位置 position
Buffer position(int n)	将设置缓冲区的当前位置为 n , 并返回修改后的 Buffer 对象
int remaining()	返回 position 和 limit 之间的元素个数
Buffer reset()	将位置 position 转到以前设置的 mark 所在的位置
Buffer rewind()	将位置设为为 0， 取消设置的 mark

缓冲区是NIO最基本的概念，关于什么是直接缓冲区与非直接缓冲区，我放到本系列后面的文章中整理吧。感谢关注oschina博主happybks的文章：）

 

 

转载于:https://my.oschina.net/happyBKs/blog/1591135