Java8之BufferedInputStream源码

jchen104

已于 2023-05-31 13:23:52 修改

阅读量1.5k

点赞数 3

分类专栏： java I/O 文章标签： java 后端

于 2021-11-14 23:09:41 首次发布

本文链接：https://blog.csdn.net/wzngzaixiaomantou/article/details/121323839

版权

java 同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

I/O

13 篇文章 3 订阅

订阅专栏

参考文章：

《java.io.BufferedInputStream 源码分析》

《IO源码解析--一文说尽BufferedInputStream》

《BufferedInputStream 源码学习笔记》

《JavaIO之BufferedInputStream详解》

写在开头：本文为学习后的总结，可能有不到位的地方，错误的地方，欢迎各位指正。

前段时间遇到个需求涉及到了IO，趁这机会重新复习了下，这里简单记录下对缓冲流的理解。

Java中的缓冲流BufferedInputStream继承自字节流，通过减少从磁盘读取文件的次数实现了文件读写的提速。可以简单的理解为，直接使用FileInputStream每次从磁盘读取1KB数据进入内存，而缓冲流直接每次读取8KB，通过这样的方式减少了磁盘的读取次数。

Object(java.lang)
  -- InputStream(java.io)
    -- FilterInputStream(java.io)
      -- BufferedInputStream(java.io)

1、public int read(byte b[])

2、public synchronized int read()

3、private int read1(byte[] b, int off, int len)

4、public synchronized int read(byte b[], int off, int len)

一、基本功能介绍

// 默认的缓冲池大小 8KB
private static int DEFAULT_BUFFER_SIZE = 8192;

// 最大的缓冲池大小（-8的原因是兼容某些虚拟机数组自带的头信息）
private static int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;

// 缓冲数组
protected volatile byte buf[];

// 原子更新器,保证了数组的原子性,防止在 buffer 被关闭的情况下修改 buffer 数组.判断 buffer 是否被关闭的条件是 buf 数组是否为 null 
private static final
        AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =
        AtomicReferenceFieldUpdater.newUpdater
        (BufferedInputStream.class,  byte[].class, "buf");

		
// 当前缓冲区末尾的位置
protected int count;

// 当前缓冲区中读取位置的索引
protected int pos;


// 是否开启重复读的标记位
// markpos和reset()配合使用才有意义.操作步骤：
// 1.通过mark() 函数，保存pos的值到markpos中。
// 2.通过reset() 函数，会将pos的值重置为markpos。
protected int markpos = -1;

// 可重复读的最大长度，即markpos到pos的长度限制
protected int marklimit;

    public BufferedInputStream(InputStream in) {
        this(in, DEFAULT_BUFFER_SIZE);
    }

     public BufferedInputStream(InputStream in, int size) {
        super(in);
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");
        }
        buf = new byte[size];
    }

count、pos、markpos的位置关系如下。

BufferedInputStream在内部构建一个缓冲池，每次会从数据源获取一定容量的数据填充到缓冲池中，在这个缓冲池中，pos是当前读取位置的索引，count是缓冲池末尾的位置。markpos默认值-1，可以通过mark(marklimit)方法将值设置为大于等于0，此时我们可以调用reset方法对已读取过的文件进行重复读取（即从markpos到pos这段的数据）。但这个重复读的长度限制也是有限制的，即marklimit。

二、主体方法

1、流的操作

1.1、getInIfOpen()：获取底层 InputStream 的对象,如果流被关闭就抛异常.该方法除了获取底层流还可以判断流是否关闭,通过抛异常终端后续操作.

1.2、getBufIfOpen()：获取 buffer 数组对象引用,如果流被关闭就抛异常.所以该方法除了获取底层流还可以判断流是否关闭,通过抛异常终端后续操作.

1.3、close()：操作很简单,就是置空缓存数组和关闭流.

// 获取输入流
private InputStream getInIfOpen() throws IOException {
    InputStream input = in;
    if (input == null)
        throw new IOException("Stream closed");
    return input;
}

// 获取缓冲区
private byte[] getBufIfOpen() throws IOException {
    byte[] buffer = buf;
    if (buffer == null)
        throw new IOException("Stream closed");
    return buffer;
}


// 关闭输入流
public void close() throws IOException {
    byte[] buffer;
    while ( (buffer = buf) != null) {
        if (bufUpdater.compareAndSet(this, buffer, null)) {
            InputStream input = in;
            in = null;
            if (input != null)
                input.close();
            return;
        }
        // Else retry in case a new buf was CASed in fill()
    }
}

2、辅助功能

1. available()：返回还有多少字节可读。n代表当前缓冲区的可读字节数，avail代表数据源的可读字节数。返回 (n + avail) 与 MAX_VALUE 中较小的一方。

// 返回还有多少字节可读
public synchronized int available() throws IOException {
    int n = count - pos;
    int avail = getInIfOpen().available();
    return n > (Integer.MAX_VALUE - avail)
                ? Integer.MAX_VALUE
                : n + avail;
}

2. skip()：跳过一定数量字节

计算当前缓冲区的未写出字节数为avail：

（1）如果avail大于0，跳过n与avail中较小的数量的字节，返回这个较小的数。

（2）如果avail小于等于0：

（2.1）无标记，直接在源输入流跳过n个字节。
（2.2）有标记，将被标记的那段缓存往左移动首处，然后重新计算avail，如果仍然小于等于0，则返回0，代表跳过了0个字节

// 跳过一定数量字节
public synchronized long skip(long n) throws IOException {
    getBufIfOpen(); // Check for closed stream
    if (n <= 0) {
        return 0;
    }
    long avail = count - pos;

    if (avail <= 0) {
        // If no mark position set then don't keep in buffer
        if (markpos <0)
            return getInIfOpen().skip(n);

        // Fill in buffer to save bytes for reset
        fill();
        avail = count - pos;
        if (avail <= 0)
            return 0;
    }

    long skipped = (avail < n) ? avail : n;
    pos += skipped;
    return skipped;
}

3. mark()：开启重复读功能，参数readlimit用来限制重复读的最大长度，同时将当前读取位置的索引pos赋值给markpos，供reset使用

// 开启重复读功能
public synchronized void mark(int readlimit) {
    marklimit = readlimit;
    markpos = pos;
}

4. reset()：重置读取位置，将读取位置pos重新定位到之前调用mark方法时标记的重复读的起始位置。

// 重置函数
public synchronized void reset() throws IOException {
    getBufIfOpen(); // Cause exception if closed
    if (markpos < 0)
        throw new IOException("Resetting to invalid mark");
    pos = markpos;
}

5. fill()：填充缓冲区。fill方法是缓冲区填充的重要逻辑，这里我再拆分成几块来简化理解。

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    if (markpos < 0)
        pos = 0;            /* no mark: throw away the buffer */
    else if (pos >= buffer.length)  /* no room left in buffer */
        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 if (buffer.length >= MAX_BUFFER_SIZE) {
            throw new OutOfMemoryError("Required array size too large");
        } else {            /* grow buffer */
            int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
                pos * 2 : MAX_BUFFER_SIZE;
            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;
}

private void fill() throws IOException {
    byte[] buffer = getBufIfOpen();
    if (markpos < 0){
        // (1) 未启用重复读 markpos = -1
    }else if (pos >= buffer.length){
        // (2) 启用重复读 markpos >=0
        if (markpos > 0){  // （2.1）markpos > 0          
        }else if (buffer.length >= marklimit){  // （2.2）markpos == 0           
        }else if (buffer.length >= MAX_BUFFER_SIZE) {  //  （2.3）溢出判断            
        }else{    // （2.4）正常扩容            
        }
    }
    count = pos;
    // 从数据源获取数据
    int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
    if (n > 0)
        // 读取数据后计算出新的 count
        count = n + pos;
}

（1）markpos < 0：未开启重复读功能，直接将pos设置为0，从头读取

（2）markpos >=0且pos>=buffer.length：

（2.1）markpos > 0 :

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;
 }

因为markpos>0，所以必然有pos - markpos<buffer.length，需要把markpos-pos这一段

复制到buffer的开头进行保存，同时将markpos置位0。

（2.2）buffer.length >= marklimit：

else if (buffer.length >= marklimit) {
     markpos = -1;   /* buffer got too big, invalidate mark */
     pos = 0;        /* drop buffer contents */
}

这一步根据上面的判断筛选后必然存在markpos==0，相当于需要重复读的长度为整个buffer数组，这里就需要确认buffer.length是否超过了允许重复读的长度上限marklimit。因此直接将markpos置为-1，关闭重复读，同时将pos置为0，buffer从头开始写。

（2.3）buffer.length >= MAX_BUFFER_SIZE：数组长度大于规定容量最大值 MAX_BUFFER_SIZE，内存溢出。

else if (buffer.length >= MAX_BUFFER_SIZE) {
    throw new OutOfMemoryError("Required array size too large");
}

（2.4）正常扩容：

else {
    // pos <= MAX_BUFFER_SIZE - pos 相当于判断 pos 大小是否大于 MAX_BUFFER_SIZE 的一半
    // nsz 为 buffer 容量扩充后的大小
    //      pos >=  MAX_BUFFER_SIZE/2 时 nsz = MAX_BUFFER_SIZE
    //      pos < MAX_BUFFER_SIZE/2   时 nsz = pos * 2
    int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
      pos * 2 : MAX_BUFFER_SIZE;
    if (nsz > marklimit)
      // nsz 大小不可以超过 marklimit
      nsz = marklimit;
    // 创建大小为 nsz 新的 buffer 数组
    byte nbuf[] = new byte[nsz];
    // 把旧数组中的数据复制到新的数组中
    System.arraycopy(buffer, 0, nbuf, 0, pos);
    if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
      // 在高并发场景下,调用 compareAndSet() 可保证流还没有被关闭
      throw new IOException("Stream closed");
    }
    // 把 buffer 底层字节数组换成新的扩容后的数组
    buffer = nbuf;
  }

取2倍pos，marklimit以及MAX_BUFFER_SIZE三者中最小的数为size，创建一个byte数组，并将当前缓冲区的所有数据拷贝到这个扩大后的数组中，另这个扩大后的数组为当前类的缓冲区。