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的文章:)