BufferedInputStream源码分析，解答readlimit相关的问题

最新推荐文章于 2022-03-09 12:16:04 发布
最新推荐文章于 2022-03-09 12:16:04 发布
阅读量1k 收藏 3
点赞数 2
分类专栏： 编程 文章标签： IO
随意转载。
本文链接：https://blog.csdn.net/dengjili/article/details/79416467
版权

承接上面一个主题：BufferedInputStream中，readlimit相关的问题

BufferedInputStream源码分析

这里写图片描述
BufferedInputStream类是一个装饰者子类，FilterInputStream为装饰者基类，InputStream类和其子类是被包装的类

原理图

原始InputStream读取方式，应用程序直接从物理设备上读取数据
这里写图片描述
BufferedInputStream读取方式，增加缓冲区数组，应用程序从数组中读取数据，减少与物理设备交互的次数
这里写图片描述

完整源代码

BufferedInputStream 

import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

public class BufferedInputStream extends FilterInputStream {
    private static int DEFAULT_BUFFER_SIZE = 8192;
    private static int MAX_BUFFER_SIZE = 2147483639;
    protected volatile byte[] buf;
    private static final AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater = AtomicReferenceFieldUpdater
            .newUpdater(BufferedInputStream.class, byte[].class, "buf");
    protected int count;
    protected int pos;
    protected int markpos = -1;
    protected int marklimit;

    private InputStream getInIfOpen() throws IOException {
        InputStream localInputStream = this.in;
        if (localInputStream == null) {
            throw new IOException("Stream closed");
        }
        return localInputStream;
    }

    private byte[] getBufIfOpen() throws IOException {
        byte[] arrayOfByte = this.buf;
        if (arrayOfByte == null) {
            throw new IOException("Stream closed");
        }
        return arrayOfByte;
    }

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

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

    private void fill() throws IOException {
        byte[] localObject = getBufIfOpen();
        if (this.markpos < 0) {
            this.pos = 0;
        } else if (this.pos >= localObject.length) {
            if (this.markpos > 0) {
                int i = this.pos - this.markpos;
                System.arraycopy(localObject, this.markpos, localObject, 0, i);
                this.pos = i;
                this.markpos = 0;
            } else if (localObject.length >= this.marklimit) {
                this.markpos = -1;
                this.pos = 0;
            } else {
                if (localObject.length >= MAX_BUFFER_SIZE) {
                    throw new OutOfMemoryError("Required array size too large");
                }
                int i = this.pos <= MAX_BUFFER_SIZE - this.pos ? this.pos * 2 : MAX_BUFFER_SIZE;
                if (i > this.marklimit) {
                    i = this.marklimit;
                }
                byte[] arrayOfByte = new byte[i];
                System.arraycopy(localObject, 0, arrayOfByte, 0, this.pos);
                if (!bufUpdater.compareAndSet(this, localObject, arrayOfByte)) {
                    throw new IOException("Stream closed");
                }
                localObject = arrayOfByte;
            }
        }
        this.count = this.pos;
        int i = getInIfOpen().read((byte[]) localObject, this.pos, localObject.length - this.pos);
        if (i > 0) {
            this.count = (i + this.pos);
        }
    }

    public synchronized int read() throws IOException {
        if (this.pos >= this.count) {
            fill();
            if (this.pos >= this.count) {
                return -1;
            }
        }
        return getBufIfOpen()[(this.pos++)] & 0xFF;
    }

    private int read1(byte[] paramArrayOfByte, int paramInt1, int paramInt2) throws IOException {
        int i = this.count - this.pos;
        if (i <= 0) {
            if ((paramInt2 >= getBufIfOpen().length) && (this.markpos < 0)) {
                return getInIfOpen().read(paramArrayOfByte, paramInt1, paramInt2);
            }
            fill();
            i = this.count - this.pos;
            if (i <= 0) {
                return -1;
            }
        }
        int j = i < paramInt2 ? i : paramInt2;
        System.arraycopy(getBufIfOpen(), this.pos, paramArrayOfByte, paramInt1, j);
        this.pos += j;
        return j;
    }

    public synchronized int read(byte[] paramArrayOfByte, int paramInt1, int paramInt2) throws IOException {
        getBufIfOpen();
        if ((paramInt1 | paramInt2 | paramInt1 + paramInt2 | paramArrayOfByte.length - (paramInt1 + paramInt2)) < 0) {
            throw new IndexOutOfBoundsException();
        }
        if (paramInt2 == 0) {
            return 0;
        }
        int i = 0;
        for (;;) {
            int j = read1(paramArrayOfByte, paramInt1 + i, paramInt2 - i);
            if (j <= 0) {
                return i == 0 ? j : i;
            }
            i += j;
            if (i >= paramInt2) {
                return i;
            }
            InputStream localInputStream = this.in;
            if ((localInputStream != null) && (localInputStream.available() <= 0)) {
                return i;
            }
        }
    }

    public synchronized long skip(long paramLong) throws IOException {
        getBufIfOpen();
        if (paramLong <= 0L) {
            return 0L;
        }
        long l1 = this.count - this.pos;
        if (l1 <= 0L) {
            if (this.markpos < 0) {
                return getInIfOpen().skip(paramLong);
            }
            fill();
            l1 = this.count - this.pos;
            if (l1 <= 0L) {
                return 0L;
            }
        }
        long l2 = l1 < paramLong ? l1 : paramLong;
        this.pos = ((int) (this.pos + l2));
        return l2;
    }

    public synchronized int available() throws IOException {
        int i = this.count - this.pos;
        int j = getInIfOpen().available();
        return i > Integer.MAX_VALUE - j ? Integer.MAX_VALUE : i + j;
    }

    public synchronized void mark(int paramInt) {
        this.marklimit = paramInt;
        this.markpos = this.pos;
    }

    public synchronized void reset() throws IOException {
        getBufIfOpen();
        if (this.markpos < 0) {
            throw new IOException("Resetting to invalid mark");
        }
        this.pos = this.markpos;
    }

    public boolean markSupported() {
        return true;
    }

    public void close() throws IOException {
        byte[] arrayOfByte;
        while ((arrayOfByte = this.buf) != null) {
            if (bufUpdater.compareAndSet(this, arrayOfByte, null)) {
                InputStream localInputStream = this.in;
                this.in = null;
                if (localInputStream != null) {
                    localInputStream.close();
                }
                return;
            }
        }
    }
}
分步骤分析源代码
不考虑mark，逻辑如下

这里写图片描述

  1. 当前有一个输入流为：1到17数字，有一个8字节的缓冲区数组

  2. 当应用程序开始读取数据的时候，如果pos=count（缓冲区没有数据，或者缓冲区数据已经读取完），需要重新重输入流中读出数据到缓冲数组，具体代码如下

  3. 读取流程如图所示，知道读取完所有数据

public synchronized int read() throws IOException {
        if (this.pos >= this.count) {
            fill();     //向缓冲区中填写数据
            if (this.pos >= this.count) {
                return -1;
            }
        }
        return getBufIfOpen()[(this.pos++)] & 0xFF;
    }
考虑mark，逻辑如下
情景1

这里写图片描述

情景2

这里写图片描述

情景3

这里写图片描述

情景4

这里写图片描述

情景5

这里写图片描述

对应代码翻译
    private void fill() throws IOException {
        byte[] localObject = getBufIfOpen();    //获取缓冲区数组
        if (this.markpos < 0) {         //初始值为-1，当markpos值为-1时，逻辑为未使用mark，
            this.pos = 0;
        } else if (this.pos >= localObject.length) {    //pos值等于缓冲区数组最大长度，缓冲区没有空间了
            if (this.markpos > 0) {     //【情景1】【情景2】markpos位置在缓冲区数组中间位置
                int i = this.pos - this.markpos;
                System.arraycopy(localObject, this.markpos, localObject, 0, i);     //标记区间前移，缓冲区空间为剩下的大小
                this.pos = i;
                this.markpos = 0;   //将markpos置为0，当下次缓冲区数组不够用时候，markpos将会失效
            } else if (localObject.length >= this.marklimit) {  
                //【情景3】
                //此时的markpos = 0，如果条件成立，localObject.length >= this.marklimit + markpos
                //根据文档定义，readlimit 参数告知此输入流在标记位置无效之前允许读取的字节数
                //条件成立，读取的长度已经超过了被允许读取的字节数，mark失效
                this.markpos = -1;
                this.pos = 0;
            } else {
                //此时的markpos = 0，且localObject.length < this.marklimit
                //readlimit标记的长度超过了缓冲区数组，扩充缓冲区数组大小
                //读取的长度未超过了被允许读取的字节数，mark有效，

                if (localObject.length >= MAX_BUFFER_SIZE) {
                    throw new OutOfMemoryError("Required array size too large");
                }
                int i = this.pos <= MAX_BUFFER_SIZE - this.pos ? this.pos * 2 : MAX_BUFFER_SIZE;
                //【情景4】扩展区间不超过标记后允许读取的字节
                if (i > this.marklimit) {
                    i = this.marklimit;
                }

                //不是情景4，即为【情景5】
                byte[] arrayOfByte = new byte[i];
                System.arraycopy(localObject, 0, arrayOfByte, 0, this.pos);
                if (!bufUpdater.compareAndSet(this, localObject, arrayOfByte)) {
                    throw new IOException("Stream closed");
                }
                localObject = arrayOfByte;
            }
        }
        this.count = this.pos;
        //从设备中读取数据到缓冲区数组中
        int i = getInIfOpen().read((byte[]) localObject, this.pos, localObject.length - this.pos);
        if (i > 0) {
            //获取缓冲区数组末位置
            this.count = (i + this.pos);
        }
    }
readlimit相关的问题

原文档
这里写图片描述

由情景3得知，markpos失效不仅需要超过readlimit，而且还需要达到缓冲区填满，才会失效

完整图

图太大了，提供一个链接：http://download.csdn.net/download/dengjili/10267728

运用一下刚刚的分析

读取两次输入数据流

具体代码如下

package other;

import java.io.ByteArrayInputStream;
import java.io.IOException;

public class MarkExample {

    public static void main(String[] args) {
        try {
            // 初始化一个字节数组，内有10个字节的数据
            byte[] bytes = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
            // 用一个ByteArrayInputStream来读取这个字节数组
            ByteArrayInputStream in = new ByteArrayInputStream(bytes);
            // 将ByteArrayInputStream包含在一个BufferedInputStream
            BufferedInputStream bis = new BufferedInputStream(in, 10);

            //超出缓冲区，情景4
            bis.mark(12);
            //bis.mark(11);报错，请自己分析一下，很容易的

            int c;
            while ( (c = bis.read()) != -1) {
                System.out.print(c + ",");
            }

            System.out.println("\nreset");
            bis.reset();
            while ( (c = bis.read()) != -1) {
                System.out.print(c + ",");
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

测试结果

1,2,3,4,5,6,7,8,9,10,11,
reset
1,2,3,4,5,6,7,8,9,10,11,
拓展

分析bis.mark(11);报错，请自己分析一下，很容易的

dengjili
关注
专栏目录
java io InputStream源码分析
许诗宇的博客
10-27 278
目录 简介 三个read skip，available，close mark，reset，markSupported 简介 /** * InputStream，这个抽象类是所有代表字节输入流的类的父类。 * * <p>需要定义InputStream的子类的程序，必须始终提供返回下一个输入字节的方法。 * * @author Arthur van Hoff * @see java.io.BufferedInputStream * @see java.
BufferedInputStream源码逐行解析【java8】
qq_36223406的博客
06-09 356
BufferedInputStream源码阅读
BufferedInputStream 源码分析
asivy的专栏
01-23 1318
转自：http://www.fengfly.com/plus/view-214062-1.html BufferedInputStream 是缓冲输入流。它继承于FilterInputStream。 BufferedInputStream 的作用是为另一个输入流添加一些功能，例如，提供“缓冲功能”以及支持“mark()标记”和“reset()重置方法”。 BufferedInputS
（三）BufferedInputStream源码学习
大股的博客
11-29 222
package java.io; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; public class BufferedInputStream extends FilterInputStream { private static int defaultBufferSize = 8192; //缓冲区
Java8之BufferedInputStream源码
CRUD工程师
11-14 1589
参考文章： 《java.io.BufferedInputStream 源码分析》 《IO源码解析--一文说尽BufferedInputStream》 《BufferedInputStream 源码学习笔记》 《JavaIO之BufferedInputStream详解》 写在开头：本文为学习后的总结，可能有不到位的地方，错误的地方，欢迎各位指正。 前段时间遇到个需求涉及到了IO，趁这机会重新复习了下，这里简单记录下对缓冲流的理解。 Java中的缓冲流BufferedInputStr...
JDK源码（一）：BufferedInputStream
u011175079的博客
03-16 186
学习更多源码，请关注微信公众号：jdkSpring，或者微信扫一下二维码：
BufferedInputStream源码分析图
03-03
BufferedInputStream源码分析图
BufferedInputStream源码分析
lzf的博客
03-27 374
BufferedInputStream内部维护一个缓冲字节数组， 当调用read(byte[] b)方法时，核心原理是将内部缓冲字节数组的内容，浅复制到方法参数的目标字节数组中。
java io BufferedInputStream源码分析
许诗宇的博客
11-05 218
目录 简介 字段DEFAULT_BUFFER_SIZE，MAX_BUFFER_SIZE，buf，bufUpdater，count，pos，markpos，marklimit 两个getXXXOpen方法，两个构造函数 fill方法和3个read方法 其余方法 简介 package java.io; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; /** * BufferedInputStream将缓冲输入并支
Java IO：BufferedInputStream使用详解及源码分析
ahsxsk的学习之路
04-26 4141
使用方法　　BufferedInputStream继承于FilterInputStream，提供缓冲输入流功能。缓冲输入流相对于普通输入流的优势是，它提供了一个缓冲数组，每次调用read方法的时候，它首先尝试从缓冲区里读取数据，若读取失败（缓冲区无可读数据），则选择从物理数据源（譬如文件）读取新数据（这里会尝试尽可能读取多的字节）放入到缓冲区中，最后再将缓冲区中的内容部分或全部返回给用户.由于从缓冲
BufferedInputStream源码阅读
Happy博客
07-11 217
前言 BufferedInputStream 使用 装饰者模式 对InputStream的功能进行了加强。通过阅读该类的代码实现，对理解装饰者模式大有助益。 继承体系 FilterInputStream FilterInputStream 类的定义就已经用到了装饰者模式——它本身继承自抽象类InpuStream，又定义了一个InputStream的成员变量 in，而且对继承的所有抽象方法的实现...
BufferedInputStream源码学习笔记
weixin_42273608的博客
03-09 221
BufferedInputStream 带有缓冲功能，支持标记（mark），最重要的函数是fill(),为类私有，可实现将部分数据从输入流填充到缓冲区（一个byte[]保存），它也能将缓冲区扩大。它是一个装饰类（装饰者模式在这里不做介绍）。 BufferedInputStream定义： public class BufferedInputStream extends FilterInputStre...
JDK1.8源码学习--io包(BufferedInputStream)
w5_Silence的博客
12-18 519
前言 月是一轮明镜,晶莹剔透,代表着一张白纸(啥也不懂) 央是一片海洋,海乃百川,代表着一块海绵(吸纳万物) 泽是一柄利剑,千锤百炼,代表着千百锤炼(输入输出) 月央泽,学习的一种过程,从白纸->吸收各种知识->不断输入输出变成自己的内容 希望大家一起坚持这个过程,也同样希望大家最终都能从零到零,把知识从薄变厚,再由厚变薄! 一.BufferedInputStream的作用: 直接看源码注释(我的翻译可能不太准,如果道友们有更棒的理解,可以留言或者私信)...
java.io.BufferedInputStream 源码分析
Forever_and_ever的博客
04-02 324
BufferedInputStream 是带有缓存区的输入字节流，使用byte[ ] 数组来进行缓存。当需要从外界读入数据到内存中时，先一次性读取多个字节的数据存放到byte[ ] 数组当中。之后对数据的存取都是操作byte[ ] 数组这个缓存区，从而提高了性能。 BufferedInputStream类结构如下所示： 在java的io模块中经常看到装饰器模式的身影，FilterInputStream 利用装饰器模式将InputStream 封装成类的成员变量 class FilterInpu.
Java中IO框架——BufferedInputStream源码解析
在梅边的专栏
02-25 446
BufferedInputStream 继承自 FilterInputStream 。 InputSteam 的源码分析见博客：http://blog.csdn.net/yx0628/article/details/79343633 FilterInputStream 的源码分析见博客：http://blog.csdn.net/yx0628/article/details/79366049 ...
JDK源码==》InputStream、OutputStream、BufferedInputStream 和 BufferedOutputStream类学习
weixin_42250577的博客
03-09 431
文章目录1、InputStream和OutputStream2、BufferedInputStream 和 BufferedOutputStreamBufferedInputStream 类的继承与实现关系及对应的成员变量、构造、方法BufferedIOutputStream 类的继承与实现关系及对应的成员变量、构造、方法demo：red读取内容：write写内容: 1、InputStream和OutputStream public abstract class InputStream implement
Java.io.BufferedInputStream.read()方法实例
wuxiaopengnihao1的博客
01-17 291
java.io.BufferedInputStream.read()方法读取从输入流中的下一个数据字节。更多教程请访问http://www.manongzj.com 声明 以下是java.io.BufferedInputStream.read()方法的声明 public int read() 参数 NA 返回值 此方法不返回任何值。 异常 IOException-- -- 如果发生I/O错误。 例子 下面的示例演示java.io.BufferedInputStream..
InputStream中mark方法readlimit参数详解
叶遮沉阳的博客
01-08 1158
InputStream中mark方法readlimit参数详解 mark(int readlimit); 网上给出的解释： /***************************************************************/ readlimit 参数给出当前输入流在标记位置变为非法前允许读取的字节数。 比如说mark(10)，那么在read()10个以内的字符时，...
BufferedInputStream类中的mark（int readlimit）方法释疑
shijinupc的专栏
01-09 3862
先看官方API文档 mark public void mark(int readlimit) See the general contract of the mark method of InputStream. Overrides: mark in classFilterInputStream Parameters: readlimit - the maximum limit
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值