NIO与IO的区别
由面向存取数据的载体、是否阻塞等可以分为以下三点不同:
面向流:
数据像水流一样传输,并且,要么输入要么输出,流是单向的。所以以前的IO流都有输入流,输出流。
面向缓冲区:
NIO会在程序与文件(磁盘、网络)之间建立一个通道用于连接,然后通过缓冲区进行数据存取,通过通道进行连接传递。
阻塞IO和非阻塞IO、选择器主要是针对网络编程而言的。
通道( 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 对象
Buffer 中的重要概念:
- 容量 (capacity) : 表示 Buffer 最大数据容量,缓冲区容量不能为负,并且创建后不能更改。
- 限制 (limit): 第一个不应该读取或写入的数据的索引,即位于 limit 后的数据不可读写。缓冲区的限制不能为负,并且不能大于其容量。
- 位置 (position): 下一个要读取或写入的数据的索引。缓冲区的位置不能为负,并且不能大于其限制
- 标记 (mark)与重置 (reset): 标记是一个索引,通过 Buffer 中的 mark() 方法指定 Buffer 中一个特定的 position,之后可以通过调用 reset() 方法恢复到这个 position。
标记、 位置、 限制、 容量遵守以下不变式: 0 <= mark <= position <= limit <= capacity
注意:mark初始化为-1,表示没有标记过。
Clearing, flipping, and rewinding说明
-
clear()
makes a buffer ready for a new sequence of channel-read or relative put operations: It sets the limit to the capacity and the position to zero.
翻译:clear()为一系列的读取通道数据到缓冲区(channel.read())或relative put操作准备好缓冲区:它将limit设置为capacity并将positon设置为零。
注意:put操作有absolute put
and relative put
操作,具体见Buffer的具体实现类如:ByteBuffer
-
flip()
makes a buffer ready for a new sequence of channel-write or relative get operations: It sets the limit to the current position and then sets the position to zero.
翻译:flip()为一些列的将缓冲区数据写入到通道(channel.write())或relative get操作准备好缓冲区:它将limit设置为当前position,然后将position设置为0。
-
rewind()
makes a buffer ready for re-reading the data that it already contains: It leaves the limit unchanged and sets the position to zero.
翻译:rewind()为重新读取它已经包含的数据准备好缓冲区:它使limit保持不变并将position设置为零。
四个核心属性与缓冲区的存取操作的关系
我们通过下面简单的图例进行了解
1、allocate(int)申请缓冲区
当我们用XxxBuffer申请allocate(int)了一个缓冲区后,我们得到了一个capacity为指定参数的大小的数组缓冲区。当前我们什么都没做,position当然保持在初始0的位置,因为初始状态没有切换到读模式,没有什么需要标记其后不能读的,写只要不超过capacity就可以,所以limit放在最后,与capacity值一样。
2、put向缓冲区写数据
当我们put()写入5个数值之后,position变为5(0到4已经写了数,若要继续写需要从5开始)。因为没有切换到读模式,所以没有什么需要声明其后不能读,写只要不超过capacity就可以,所以limit放在最后,与capacity值一样。
3、flip()将缓冲区切换成读取数据模式
当我们需要读取我们刚才写入缓冲区的数据时,首先需要做的是调用缓冲区的flip()方法,将缓冲区切换到读模式。
切换到读模式之后,我们要做的是将刚才的写入的5个数据读取出来,很自然地,postion会变回0,因为0是写入的起始位置;因为刚才只写入了5个,因此数据只写到0-4,所以从第5个开始之后的不能被读取,所以limit变成5,限定5开始之后的缓冲区空间不能够被读取。postion会随着读而变化位置。
如果调用了rewind()准备重读,那么position一定变回为0。
如果读到当中的某个位置我们mark()了,这个标记的postion值会被缓冲区的核心属性mark记录下来,等到后来reset()的时候,mark属性记录的值会赋给position属性,用于回到刚才mark标记的位置用于重读。
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 |
测试代码
package com;
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():获取缓冲区中的数据
*
* 要想对缓冲区的数据进行正确的存取的话,必须要先了解几个缓冲区的核心属性
*
*
* 三、缓冲区中的四个核心属性:<br/>
* capacity:容量,表示缓冲区中最大存储数据的容量。一旦声明不能改变。(因为缓冲区就是数组,数组大小不可改变)<br/>
* limit:界限,表示缓冲区中可以操作数据的大小。(limit后面的数据不能进行读写) <br/>
* position:位置,表示缓冲区正在操作数据的位置。<br/>
*
* position <= limit <= capacity
*
* mark:标记,表示记录当前position的位置。可以用过reset()恢复到mark的位置。
*
* 0 <= mark <= position <= limit <= capacity
*
* mark初始化为-1,表示没有标记过
*/
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());
}
}
}
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