副标题#e#
BufferedInputStream(缓冲输入流)的认知、源码和示例
本章内容包罗3个部门：BufferedInputStream先容，BufferedInputStream源码，以及BufferedInputStream利用示例。
BufferedInputStream 先容
BufferedInputStream 是缓冲输入流。它担任于FilterInputStream。
BufferedInputStream 的浸染是为另一个输入流添加一些成果，譬喻，提供“缓冲成果”以及支持“mark()标志”和“reset()重置要领”。
BufferedInputStream 本质上是通过一个内部缓冲区数组实现的。譬喻，在新建某输入流对应的BufferedInputStream后，当我们通过read()读取输入流的数据时，BufferedInputStream会将该输入流的数据分批的填入到缓冲区中。每当缓冲区中的数据被读完之后，输入流会再次填凑数据缓冲区；如此重复，直到我们读完输入流数据位置。
BufferedInputStream 函数列表
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)
synchronized int available()
void close()
synchronized void mark(int readlimit)
boolean markSupported()
synchronized int read()
synchronized int read(byte[] buffer, int offset, int byteCount)
synchronized void reset()
synchronized long skip(long byteCount)
BufferedInputStream 源码阐明(基于jdk1.7.40)
package java.io;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
public class BufferedInputStream extends FilterInputStream {
// 默认的缓冲巨细是8192字节
// BufferedInputStream 会按照“缓冲区巨细”来逐次的填充缓冲区；
// 即，BufferedInputStream填充缓冲区，用户读取缓冲区，读完之后，BufferedInputStream会再次填充缓冲区。如此轮回，直到读完数据...
private static int defaultBufferSize = 8192;
// 缓冲数组
protected volatile byte buf[];
// 缓存数组的原子更新器。
// 该成员变量与buf数组的volatile要害字配合构成了buf数组的原子更新成果实现，
// 即，在多线程中操纵BufferedInputStream工具时，buf和bufUpdater都具有原子性(差异的线程会见到的数据都是沟通的)
private static final
AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =
AtomicReferenceFieldUpdater.newUpdater
(BufferedInputStream.class, byte[].class, "buf");
// 当前缓冲区的有效字节数。
// 留意，这里是指缓冲区的有效字节数，而不是输入流中的有效字节数。
protected int count;
// 当前缓冲区的位置索引
// 留意，这里是指缓冲区的位置索引，而不是输入流中的位置索引。
protected int pos;
// 当前缓冲区的标志位置
// markpos和reset()共同利用才有意义。操纵步调：
// (01) 通过mark() 函数，生存pos的值到markpos中。
// (02) 通过reset() 函数，会将pos的值重置为markpos。接着通过read()读取数据时，就会从mark()生存的位置开始读取。
protected int markpos = -1;
// marklimit是标志的最大值。
// 查察本栏目
说明：
要想读懂BufferedInputStream的源码，就要先领略它的思想。BufferedInputStream的浸染是为其它输入流提供缓冲成果。建设BufferedInputStream时，我们会通过它的结构函数指定某个输入流为参数。BufferedInputStream会将该输入流数据分批读取，每次读取一部门到缓冲中；操纵完缓冲中的这部门数据之后，再从输入流中读取下一部门的数据。
为什么需要缓冲呢？原因很简朴，效率问题！缓冲中的数据实际上是生存在内存中，而原始数据大概是生存在硬盘或NandFlash等存储介质中；而我们知道，从内存中读取数据的速度比从硬盘读取数据的速度至少快10倍以上。
那干嘛不爽性一次性将全部数据都读取到缓冲中呢？第一，读取全部的数据所需要的时间大概会很长。第二，内存价值很贵，容量不像硬盘那么大。
下面，我就BufferedInputStream中最重要的函数fill()举办说明。其它的函数很容易领略，我就不具体先容了，各人可以参考源码中的注释举办领略。
fill() 源码如下：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos < 0)
pos = 0;
else if (pos >= buffer.length) {
if (markpos > 0) { /* can throw away early part of the buffer */
int sz = pos - markpos;
System.arraycopy(buffer, markpos, buffer, 0, sz);
pos = sz;
markpos = 0;
} else if (buffer.length >= marklimit) {
markpos = -1; /* buffer got too big, invalidate mark */
pos = 0; /* drop buffer contents */
} else { /* grow buffer */
int nsz = pos * 2;
if (nsz > marklimit)
nsz = marklimit;
byte nbuf[] = new byte[nsz];
System.arraycopy(buffer, 0, nbuf, 0, pos);
if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
// Can't replace buf if there was an async close.
// Note: This would need to be changed if fill()
// is ever made accessible to multiple threads.
// But for now, the only way CAS can fail is via close.
// assert buf == null;
throw new IOException("Stream closed");
}
buffer = nbuf;
}
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
按照fill()中的if...else...，下面我们将fill分为5种环境举办说明。
环境1：读取完buffer中的数据，而且buffer没有被标志
执行流程如下，
(01) read() 函数中挪用 fill()
(02) fill() 中的 if (markpos < 0) ...
#p#分页标题#e#
为了利便阐明，我们将这种环境下fill()执行的操纵等价于以下代码：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos < 0)
pos = 0;
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
说明：
这种环境产生的环境是 — — 输入流中有很长的数据，我们每次从中读取一部门数据到buffer中举办操纵。每次当我们读取完buffer中的数据之后，而且此时输入流没有被标志；那么，就接着从输入流中读取下一部门的数据到buffer中。
个中，判定是否读完buffer中的数据，是通过 if (pos >= count) 来判定的；
判定输入流有没有被标志，是通过 if (markpos < 0) 来判定的。
领略这个思想之后，我们再对这种环境下的fill()的代码举办阐明，就出格容易领略了。
(01) if (markpos < 0) 它的浸染是判定“输入流是否被标志”。若被标志，则markpos大于/便是0；不然markpos便是-1。
(02) 在这种环境下：通过getInIfOpen()获取输入流，然后接着从输入流中读取buffer.length个字节到buffer中。
(03) count = n + pos; 这是按照从输入流中读取的实际数据的几多，来更新buffer中数据的实际巨细。
环境2：读取完buffer中的数据，buffer的标志位置>0，而且buffer中没有多余的空间
执行流程如下，
(01) read() 函数中挪用 fill()
(02) fill() 中的 else if (pos >= buffer.length) ...
(03) fill() 中的 if (markpos > 0) ...
为了利便阐明，我们将这种环境下fill()执行的操纵等价于以下代码：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos >= 0 && pos >= buffer.length) {
if (markpos > 0) {
int sz = pos - markpos;
System.arraycopy(buffer, markpos, buffer, 0, sz);
pos = sz;
markpos = 0;
}
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
说明：
这种环境产生的环境是 — — 输入流中有很长的数据，我们每次从中读取一部门数据到buffer中举办操纵。当我们读取完buffer中的数据之后，而且此时输入流存在标志时；那么，就产生环境2。此时，我们要保存“被标志位置”到“buffer末端”的数据，然后再从输入流中读取下一部门的数据到buffer中。
个中，判定是否读完buffer中的数据，是通过 if (pos >= count) 来判定的；
判定输入流有没有被标志，是通过 if (markpos < 0) 来判定的。
判定buffer中没有多余的空间，是通过 if (pos >= buffer.length) 来判定的。
领略这个思想之后，我们再对这种环境下的fill()代码举办阐明，就出格容易领略了。
(01) int sz = pos - markpos; 浸染是“获取‘被标志位置’到‘buffer末端’”的数据长度。
(02) System.arraycopy(buffer, markpos, buffer, 0, sz); 浸染是“将buffer中从markpos开始的数据”拷贝到buffer中(从位置0开始填充，填充长度是sz)。接着，将sz赋值给pos，即pos就是“被标志位置”到“buffer末端”的数据长度。
(03) int n = getInIfOpen().read(buffer, pos, buffer.length - pos); 从输入流中读取出“buffer.length - pos”的数据，然后填充到buffer中。
(04) 通过第(02)和(03)步组合起来的buffer，就是包括了“原始buffer被标志位置到buffer末端”的数据，也包括了“从输入流中新读取的数据”。
留意：执行过环境2之后，markpos的值由“大于0”酿成了“便是0”！
环境3：读取完buffer中的数据，buffer被标志位置=0，buffer中没有多余的空间，而且buffer.length>=marklimit
执行流程如下，
(01) read() 函数中挪用 fill()
(02) fill() 中的 else if (pos >= buffer.length) ...
(03) fill() 中的 else if (buffer.length >= marklimit) ...
#p#分页标题#e#
为了利便阐明，我们将这种环境下fill()执行的操纵等价于以下代码：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos >= 0 && pos >= buffer.length) {
if ( (markpos <= 0) && (buffer.length >= marklimit) ) {
markpos = -1; /* buffer got too big, invalidate mark */
pos = 0; /* drop buffer contents */
}
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
说明：这种环境的处理惩罚很是简朴。首先，就是“打消标志”，即 markpos = -1；然后，配置初始化位置为0，即pos=0；最后，再从输入流中读取下一部门数据到buffer中。
环境4：读取完buffer中的数据，buffer被标志位置=0，buffer中没有多余的空间，而且buffer.length<marklimit
执行流程如下，
(01) read() 函数中挪用 fill()
(02) fill() 中的 else if (pos >= buffer.length) ...
(03) fill() 中的 else { int nsz = pos * 2; ... }
为了利便阐明，我们将这种环境下fill()执行的操纵等价于以下代码：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
if (markpos >= 0 && pos >= buffer.length) {
if ( (markpos <= 0) && (buffer.length < marklimit) ) {
int nsz = pos * 2;
if (nsz > marklimit)
nsz = marklimit;
byte nbuf[] = new byte[nsz];
System.arraycopy(buffer, 0, nbuf, 0, pos);
if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
throw new IOException("Stream closed");
}
buffer = nbuf;
}
}
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
说明：
这种环境的处理惩罚很是简朴。
(01) 新建一个字节数组nbuf。nbuf的巨细是“pos*2”和“marklimit”中较小的谁人数。
int nsz = pos * 2;
if (nsz > marklimit)
nsz = marklimit;
byte nbuf[] = new byte[nsz];
(02) 接着，将buffer中的数据拷贝到新数组nbuf中。通过System.arraycopy(buffer, 0, nbuf, 0, pos)
(03) 最后，从输入流读取部门新数据到buffer中。通过getInIfOpen().read(buffer, pos, buffer.length - pos);
留意：在这里，我们思考一个问题，“为什么需要marklimit，它的存在到底有什么意义？”我们团结“环境2”、“环境3”、“环境4”的环境来阐明。
假设，marklimit是无限大的，并且我们配置了markpos。当我们从输入流中每读完一部门数据并读取下一部门数据时，都需要生存markpos所标志的数据；这就意味着，我们需要不绝执行环境4中的操纵，要将buffer的容量扩大……跟着读取次数的增多，buffer会越来越大；这会导致我们占据的内存越来越大。所以，我们需要给出一个marklimit；当buffer>=marklimit时，就不再生存markpos的值了。
环境5：除了上面4种环境之外的环境
执行流程如下，
(01) read() 函数中挪用 fill()
(02) fill() 中的 count = pos...
为了利便阐明，我们将这种环境下fill()执行的操纵等价于以下代码：
private void fill() throws IOException {
byte[] buffer = getBufIfOpen();
count = pos;
int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
if (n > 0)
count = n + pos;
}
说明：这种环境的处理惩罚很是简朴。直接从输入流读取部门新数据到buffer中。
示例代码
关于BufferedInputStream中API的具体用法，参考示例代码(BufferedInputStreamTest.java)：
import java.io.BufferedInputStream;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.FileNotFoundException;
import java.lang.SecurityException;
/**
* BufferedInputStream 测试措施
*
* @author skywang
*/
public class BufferedInputStreamTest {
private static final int LEN = 5;
public static void main(String[] args) {
testBufferedInputStream() ;
}
/**
* BufferedInputStream的API测试函数
*/
private static void testBufferedInputStream() {
// 建设BufferedInputStream字节约，内容是ArrayLetters数组
try {
File file = new File("bufferedinputstream.txt");
InputStream in =
new BufferedInputStream(
new FileInputStream(file), 512);
// 从字节约中读取5个字节。“abcde”，a对应0x61，b对应0x62，依次类推...
for (int i=0; i<LEN; i++) {
// 若能继承读取下一个字节，则读取下一个字节
if (in.available() >= 0) {
// 读取“字节约的下一个字节”
int tmp = in.read();
System.out.printf("%d : 0x%s\n", i, Integer.toHexString(tmp));
}
}
// 若“该字节约”不支持标志成果，则直接退出
if (!in.markSupported()) {
System.out.println("make not supported!");
return ;
}
// 标志“当前索引位置”，即标志第6个位置的元素--“f”
// 1024对应marklimit
in.mark(1024);
// 跳过22个字节。
in.skip(22);
// 读取5个字节
byte[] buf = new byte[LEN];
in.read(buf, 0, LEN);
// 将buf转换为String字符串。
String str1 = new String(buf);
System.out.printf("str1=%s\n", str1);
// 重置“输入流的索引”为mark()所标志的位置，即重置到“f”处。
in.reset();
// 从“重置后的字节约”中读取5个字节到buf中。即读取“fghij”
in.read(buf, 0, LEN);
// 将buf转换为String字符串。
String str2 = new String(buf);
System.out.printf("str2=%s\n", str2);
in.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}
措施中读取的bufferedinputstream.txt的内容如下：
abcdefghijklmnopqrstuvwxyz
0123456789
ABCDEFGHIJKLMNOPQRSTUVWXYZ
运行功效：
0 : 0x61
1 : 0x62
2 : 0x63
3 : 0x64
4 : 0x65
str1=01234
str2=fghij
来历：http://www.cnblogs.com/skywang12345/p/io_12.html
