JAVA NIO学习二：通道（Channel）与缓冲区（Buffer）

今天是2018年的第三天，真是时光飞逝，2017年的学习计划还没有学习完成，因此继续开始研究学习，那么上一节我们了解了NIO，那么这一节我们进一步来学习NIO相关的知识。那就是通道和缓冲区。Java NIO系统的核心在于：通道(Channel)和缓冲区(Buffer)。通道表示打开到 IO 设备(例如：文件、套接字)的连接。若需要使用 NIO 系统，需要获取用于连接 IO 设备的通道以及用于容纳数据的缓冲区。然后操作缓冲区，对数据进行处理。简而言之， Channel 负责传输， Buffer 负责存储。

一、缓冲区（Buffer）

缓冲区（Buffer）:一个用于特定基本数据类型的容器。由 java.nio 包定义的，所有缓冲区都是 Buffer 抽象类的子类。Java NIO 中的 Buffer 主要用于与 NIO 通道进行交互，数据是从通道读入缓冲区，从缓冲区写入通道中的。

缓冲区对象本质上是一个数组，但它其实是一个特殊的数组，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况，如果我们使用get()方法从缓冲区获取数据或者使用put()方法把数据写入缓冲区，都会引起缓冲区状态的变化。它可以保存多个相同类型的数据。根据数据类型不同(boolean 除外) ，有以下 Buffer 常用子类：

 ByteBuffer
 CharBuffer
 ShortBuffer
 IntBuffer
 LongBuffer
 FloatBuffer
 DoubleBuffer
上述 Buffer 类 他们都采用相似的方法进行管理数据，只是各自管理的数据类型不同而已。都是通过如下方法获取一个 Buffer对象：
static XxxBuffer allocate(int capacity) : 创建一个容量为 capacity 的 XxxBuffer 对象

在缓冲区中，最重要的属性有下面三个，它们一起合作完成对缓冲区内部状态的变化跟踪：

position：指定了下一个将要被写入或者读取的元素索引，它的值由get()/put()方法自动更新，在新创建一个Buffer对象时，position被初始化为0。

limit：指定还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)。

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

另外：

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

以上四个属性值之间有一些相对大小的关系：0 <= position <= limit <= capacity。如果我们创建一个新的容量大小为10的ByteBuffer对象，在初始化的时候，position设置为0，limit和 capacity被设置为10，在以后使用ByteBuffer对象过程中，capacity的值不会再发生变化，而其它两个个将会随着使用而变化。四个属性值分别如图所示：



现在我们可以从通道中读取一些数据到缓冲区中，注意从通道读取数据，相当于往缓冲区中写入数据。如果读取4个自己的数据，则此时position的值为4，即下一个将要被写入的字节索引为4，而limit仍然是10，如下图所示：



下一步把读取的数据写入到输出通道中，相当于从缓冲区中读取数据，在此之前，必须调用flip()方法，该方法将会完成两件事情：

1. 把limit设置为当前的position值
2. 把position设置为0

由于position被设置为0，所以可以保证在下一步输出时读取到的是缓冲区中的第一个字节，而limit被设置为当前的position，可以保证读取的数据正好是之前写入到缓冲区中的数据，如下图所示：



现在调用get()方法从缓冲区中读取数据写入到输出通道，这会导致position的增加而limit保持不变，但position不会超过limit的值，所以在读取我们之前写入到缓冲区中的4个自己之后，position和limit的值都为4，如下图所示：



在从缓冲区中读取数据完毕后，limit的值仍然保持在我们调用flip()方法时的值，调用clear()方法能够把所有的状态变化设置为初始化时的值，如下图所示



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

缓冲区的数据操作：
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)

直接与非直接缓冲区
字节缓冲区要么是直接的，要么是非直接的。如果为直接字节缓冲区，则 Java 虚拟机会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到中间缓冲区中（或从中间缓冲区中复制内容）。

直接字节缓冲区可以通过调用此类的 allocateDirect() 工厂方法来创建。此方法返回的缓冲区进行分配和取消分配所需成本通常高于非直接缓冲区。直接缓冲区的内容可以驻留在常规的垃圾回收堆之外，因此，它们对应用程序的内存需求量造成的影响可能并不明显。所以，建议将直接缓冲区主要分配给那些易受基础系统的本机 I/O 操作影响的大型、持久的缓冲区。一般情况下，最好仅在直接缓冲区能在程序性能方面带来明显好处时分配它们。直接字节缓冲区还可以通过 FileChannel 的 map() 方法 将文件区域直接映射到内存中来创建。该方法返回MappedByteBuffer 。 Java 平台的实现有助于通过 JNI 从本机代码创建直接字节缓冲区。如果以上这些缓冲区中的某个缓冲区实例指的是不可访问的内存区域，则试图访问该区域不会更改该缓冲区的内容，并且将会在访问期间或稍后的某个时间导致抛出不确定的异常。

字节缓冲区是直接缓冲区还是非直接缓冲区可通过调用其 isDirect() 方法来确定。提供此方法是为了能够在性能关键型代码中执行显式缓冲区管理。

非直接缓冲区



直接缓冲区



下面我们看下直接缓冲区的操作样例和重点：

import java.nio.ByteBuffer;

import org.junit.Test;

/*
* 一、缓冲区（Buffer）：在 Java NIO 中负责数据的存取。缓冲区就是数组。用于存储不同数据类型的数据
*
* 根据数据类型不同（boolean 除外），提供了相应类型的缓冲区：
* ByteBuffer
* CharBuffer
* ShortBuffer
* IntBuffer
* LongBuffer
* FloatBuffer
* DoubleBuffer
*
* 上述缓冲区的管理方式几乎一致，通过 allocate() 获取缓冲区
*
* 二、缓冲区存取数据的两个核心方法：
* put() : 存入数据到缓冲区中
* get() : 获取缓冲区中的数据
*
* 三、缓冲区中的四个核心属性：
* capacity : 容量，表示缓冲区中最大存储数据的容量。一旦声明不能改变。
* limit : 界限，表示缓冲区中可以操作数据的大小。（limit 后数据不能进行读写）
* position : 位置，表示缓冲区中正在操作数据的位置。
*
* mark : 标记，表示记录当前 position 的位置。可以通过 reset() 恢复到 mark 的位置
*
* 0 <= mark <= position <= limit <= capacity
*
* 四、直接缓冲区与非直接缓冲区：
* 非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中
* 直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率
*/
public class TestBuffer {

@Test
public void test3(){
//分配直接缓冲区
ByteBuffer buf = ByteBuffer.allocateDirect(1024);

System.out.println(buf.isDirect());
}

@Test
public void test2(){
String str = "abcde";

ByteBuffer buf = ByteBuffer.allocate(1024);

buf.put(str.getBytes());

buf.flip();

byte[] dst = new byte[buf.limit()];
buf.get(dst, 0, 2);
System.out.println(new String(dst, 0, 2));
System.out.println(buf.position());

//mark() : 标记
buf.mark();

buf.get(dst, 2, 2);
System.out.println(new String(dst, 2, 2));
System.out.println(buf.position());

//reset() : 恢复到 mark 的位置
buf.reset();
System.out.println(buf.position());

//判断缓冲区中是否还有剩余数据
if(buf.hasRemaining()){

//获取缓冲区中可以操作的数量
System.out.println(buf.remaining());
}
}

@Test
public void test1(){
String str = "abcde";

//1. 分配一个指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);

System.out.println("-----------------allocate()----------------");
System.out.println(buf.position());
System.out.println(buf.limit());
System.out.println(buf.capacity());

//2. 利用 put() 存入数据到缓冲区中
buf.put(str.getBytes());

System.out.println("-----------------put()----------------");
System.out.println(buf.position());
System.out.println(buf.limit());
System.out.println(buf.capacity());

//3. 切换读取数据模式
buf.flip();

System.out.println("-----------------flip()----------------");
System.out.println(buf.position());
System.out.println(buf.limit());
System.out.println(buf.capacity());

//4. 利用 get() 读取缓冲区中的数据
byte[] dst = new byte[buf.limit()];
buf.get(dst);
System.out.println(new String(dst, 0, dst.length));

System.out.println("-----------------get()----------------");
System.out.println(buf.position());
System.out.println(buf.limit());
System.out.println(buf.capacity());

//5. rewind() : 可重复读
buf.rewind();

System.out.println("-----------------rewind()----------------");
System.out.println(buf.position());
System.out.println(buf.limit());
System.out.println(buf.capacity());

//6. clear() : 清空缓冲区. 但是缓冲区中的数据依然存在，但是处于“被遗忘”状态
buf.clear();

System.out.println("-----------------clear()----------------");
System.out.println(buf.position());
System.out.println(buf.limit());
System.out.println(buf.capacity());

System.out.println((char)buf.get());

}

}

二、通道（Channel）

通道（Channel）：由 java.nio.channels 包定义的。 Channel 表示 IO 源与目标打开的连接。Channel 类似于传统的“流”。只不过 Channel本身不能直接访问数据， Channel 只能与Buffer 进行交互。

下面我们通过几张图来引入通道：



上面这张图是指当准备从磁盘或内存中copy数据，进行IO操作的时候，需要建立IO 连接，那么这个时候所有的调度中心都在CPU上面，那么当有很多IO请求的时候，那么CPU都要直接参与调度，那么势必会影响到CPU的执行效率，因为所有的IO从建立连接到传入数据都要经过CPU的操作来完成，于是为了节省CPU的占用率，于是出现了下面的改进；



这种是CPU将权利释放，只是进行审批流程，即就相当于我们现实生活工作中，领导不负责具体的工作，只负责签字审批确认即可，那么就减少了IO对CPU的影响，从而提高了CPU的利用率，但这种还是会占用到CPU的时间消耗和利用率，因此为了完全不占用CPU，于是出现了专门负责IO的专门者，就是通道：



Java 为 Channel 接口提供的最主要实现类如下：
•FileChannel：用于读取、写入、映射和操作文件的通道。
•DatagramChannel：通过 UDP 读写网络中的数据通道。
•SocketChannel：通过 TCP 读写网络中的数据。
•ServerSocketChannel：可以监听新进来的 TCP 连接，对每一个新进来的连接都会创建一个 SocketChannel。

获取通道
获取通道的一种方式是对支持通道的对象调用getChannel() 方法。支持通道的类如下：
 FileInputStream
 FileOutputStream
 RandomAccessFile
 DatagramSocket
 Socket
 ServerSocket
获取通道的其他方式是使用 Files 类的静态方法 newByteChannel() 获取字节通道。或者通过通道的静态方法 open() 打开并返回指定通道。

通道的数据传输

 将 Buffer 中数据写入 Channel
例如：



 从 Channel 读取数据到 Buffer
例如：



分散(Scatter)和聚集(Gather)
分散读取（Scattering Reads）是指从 Channel 中读取的数据“分散” 到多个 Buffer 中



注意：按照缓冲区的顺序，从 Channel 中读取的数据依次将 Buffer 填满。

聚集写入（Gathering Writes）是指将多个 Buffer 中的数据“聚集”到 Channel。



注意：按照缓冲区的顺序，写入 position 和 limit 之间的数据到 Channel 。

transferFrom()

将数据从源通道传输到其他 Channel 中：





transferTo()

将数据从源通道传输到其他 Channel 中：





FileChannel 的常用方法

方 法	描 述
int read(ByteBuffer dst)	从 Channel 中读取数据到 ByteBuffer
long read(ByteBuffer[] dsts)	将 Channel 中的数据“分散”到 ByteBuffer[]
int write(ByteBuffer src)	将 ByteBuffer 中的数据写入到 Channel
long write(ByteBuffer[] srcs)	将 ByteBuffer[] 中的数据“聚集”到 Channel
long position()	返回此通道的文件位置
FileChannel position(long p)	设置此通道的文件位置
long size()	返回此通道的文件的当前大小
FileChannel truncate(long s)	将此通道的文件截取为给定大小
void force(boolean metaData)	强制将所有对此通道的文件更新写入到存储设备中

上述样例代码和核心：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.nio.charset.CharacterCodingException;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import org.junit.Test;

/*
* 一、通道（Channel）：用于源节点与目标节点的连接。在 Java NIO 中负责缓冲区中数据的传输。Channel 本身不存储数据，因此需要配合缓冲区进行传输。
*
* 二、通道的主要实现类
*     java.nio.channels.Channel 接口：
*         |--FileChannel
*         |--SocketChannel
*         |--ServerSocketChannel
*         |--DatagramChannel
*
* 三、获取通道
* 1. Java 针对支持通道的类提供了 getChannel() 方法
*         本地 IO：
*         FileInputStream/FileOutputStream
*         RandomAccessFile
*
*         网络IO：
*         Socket
*         ServerSocket
*         DatagramSocket
*
* 2. 在 JDK 1.7 中的 NIO.2 针对各个通道提供了静态方法 open()
* 3. 在 JDK 1.7 中的 NIO.2 的 Files 工具类的 newByteChannel()
*
* 四、通道之间的数据传输
* transferFrom()
* transferTo()
*
* 五、分散(Scatter)与聚集(Gather)
* 分散读取（Scattering Reads）：将通道中的数据分散到多个缓冲区中
* 聚集写入（Gathering Writes）：将多个缓冲区中的数据聚集到通道中
*
* 六、字符集：Charset
* 编码：字符串 -> 字节数组
* 解码：字节数组  -> 字符串
*
*/
public class TestChannel {

//字符集
@Test
public void test6() throws IOException{
Charset cs1 = Charset.forName("GBK");

//获取编码器
CharsetEncoder ce = cs1.newEncoder();

//获取解码器
CharsetDecoder cd = cs1.newDecoder();

CharBuffer cBuf = CharBuffer.allocate(1024);
cBuf.put("尚硅谷威武！");
cBuf.flip();

//编码
ByteBuffer bBuf = ce.encode(cBuf);

for (int i = 0; i < 12; i++) {
System.out.println(bBuf.get());
}

//解码
bBuf.flip();
CharBuffer cBuf2 = cd.decode(bBuf);
System.out.println(cBuf2.toString());

System.out.println("------------------------------------------------------");

Charset cs2 = Charset.forName("GBK");
bBuf.flip();
CharBuffer cBuf3 = cs2.decode(bBuf);
System.out.println(cBuf3.toString());
}

@Test
public void test5(){
Map<String, Charset> map = Charset.availableCharsets();

Set<Entry<String, Charset>> set = map.entrySet();

for (Entry<String, Charset> entry : set) {
System.out.println(entry.getKey() + "=" + entry.getValue());
}
}

//分散和聚集
@Test
public void test4() throws IOException{
RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");

//1. 获取通道
FileChannel channel1 = raf1.getChannel();

//2. 分配指定大小的缓冲区
ByteBuffer buf1 = ByteBuffer.allocate(100);
ByteBuffer buf2 = ByteBuffer.allocate(1024);

//3. 分散读取
ByteBuffer[] bufs = {buf1, buf2};
channel1.read(bufs);

for (ByteBuffer byteBuffer : bufs) {
byteBuffer.flip();
}

System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));
System.out.println("-----------------");
System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));

//4. 聚集写入
RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
FileChannel channel2 = raf2.getChannel();

channel2.write(bufs);
}

//通道之间的数据传输(直接缓冲区)
@Test
public void test3() throws IOException{
FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);

//        inChannel.transferTo(0, inChannel.size(), outChannel);
outChannel.transferFrom(inChannel, 0, inChannel.size());

inChannel.close();
outChannel.close();
}

//使用直接缓冲区完成文件的复制(内存映射文件)
@Test
public void test2() throws IOException{//2127-1902-1777
long start = System.currentTimeMillis();

FileChannel inChannel = FileChannel.open(Paths.get("d:/1.mkv"), StandardOpenOption.READ);
FileChannel outChannel = FileChannel.open(Paths.get("d:/2.mkv"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);

//内存映射文件
MappedByteBuffer inMappedBuf = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
MappedByteBuffer outMappedBuf = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());

//直接对缓冲区进行数据的读写操作
byte[] dst = new byte[inMappedBuf.limit()];
inMappedBuf.get(dst);
outMappedBuf.put(dst);

inChannel.close();
outChannel.close();

long end = System.currentTimeMillis();
System.out.println("耗费时间为：" + (end - start));
}

//利用通道完成文件的复制（非直接缓冲区）
@Test
public void test1(){//10874-10953
long start = System.currentTimeMillis();

FileInputStream fis = null;
FileOutputStream fos = null;
//①获取通道
FileChannel inChannel = null;
FileChannel outChannel = null;
try {
fis = new FileInputStream("d:/1.mkv");
fos = new FileOutputStream("d:/2.mkv");

inChannel = fis.getChannel();
outChannel = fos.getChannel();

//②分配指定大小的缓冲区
ByteBuffer buf = ByteBuffer.allocate(1024);

//③将通道中的数据存入缓冲区中
while(inChannel.read(buf) != -1){
buf.flip(); //切换读取数据的模式
//④将缓冲区中的数据写入通道中
outChannel.write(buf);
buf.clear(); //清空缓冲区
}
} catch (IOException e) {
e.printStackTrace();
} finally {
if(outChannel != null){
try {
outChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}

if(inChannel != null){
try {
inChannel.close();
} catch (IOException e) {
e.printStackTrace();
}
}

if(fos != null){
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}

if(fis != null){
try {
fis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

long end = System.currentTimeMillis();
System.out.println("耗费时间为：" + (end - start));

}

}

参考资料：

《尚硅谷》视频学习