BufferedInputStream我们到底能走多远系列（3）

我们到底能走多远系列（3）

扯淡：

现在项目里的java代码，都是封装，封装，再封装。在没有空闲的赶工编码，几年后会感觉学不动，毕竟少了很多思考的时间。也基本不会去研究代码的底层实现。时间一长就会觉得自己什么也不会。

一个大型的项目，一般不可能只用java实现，可能会用到C，C++，shell，python等等。单单一个web就要学很多，jsp，jquery，javascript，html，css，各种开源的不开源的框架，各种web服务器，数据库等等等。java程序员的确容易迷茫，但精通一样吧，怕找不到工作，全学吧，怕一直是码农。

其实，我觉得大多数的人都只是希望能做到“工程师”，解决问题的人。我看到现在接近40的程序员也还是蛮吃香的，他们的能力也是这样慢慢码过来的。和他们交流的时候感觉他们什么都知道点，也有自己及其精通的一面。这个方向似乎也是一种不错的职业规划。

-----------------------------------------------------------------------------

总之，不要停止学习，不要停止进步。

-----------------------------------------------------------------------------

BufferedInputStream应该比较实用吧。读读源码，学习下。

继承结构：

BufferedInputStream ----> FilterInputStream -----> InputStream

概述：

FilterInputStream继承自InputStream属于输入流中的链接流，同时引用了InputStream，将 InputStream封装成一个内部变量，同时构造方法上需要传入一个InputStream。这是一个典型的装饰器模式，他的任何子类都可以对一个继 承自InputStream的原始流或其他链接流进行装饰，如我们常用的使用BufferedInputStream对FileInputStream进 行装饰，使普通的文件输入流具备了内存缓存的功能，通过内存缓冲减少磁盘io次数。

BufferedInputStream方法一览：

private void fill()
private byte[] getBufIfOpen()
private InputStream getInIfOpen()
private int read1(byte[] b, int off, int len)
-------------------------------------------------
public BufferedInputStream(InputStream in)
public BufferedInputStream(InputStream in, int size)
--------------------------------------------------
public synchronized int available()
返回此输入流方法的下一个调用方可以不受阻塞地从此输入流读取（或跳过）的字节数。
public void close()
关闭此输入流并释放与该流关联的所有系统资源。
public synchronized void mark(int readlimit)
在此输入流中标记当前的位置。对 reset 方法的后续调用会在最后标记的位置重新定位此流，以便后续读取重新读取相同的字节。 
readlimit - 在标记位置失效前可以读取字节的最大限制。
public boolean markSupported()
测试此输入流是否支持 mark 和 reset 方法。
public synchronized int read()
从输入流读取下一个数据字节。返回 0 到 255 范围内的 int 字节值。如果因已到达流末尾而没有可用的字节，则返回值 -1。
public synchronized int read(byte b[], int off, int len)
将输入流中最多 len 个数据字节读入字节数组。尝试读取多达 len 字节，但可能读取较少数量。以整数形式返回实际读取的字节数。 
public synchronized void reset()
将此流重新定位到对此输入流最后调用 mark 方法时的位置。
public synchronized long skip(long n)
跳过和放弃此输入流中的 n 个数据字节。

源码:

package java.io;
 
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 
//继承FilterInputStream，FilterInputStream继承InputStream
//该类主要完成对被包装流，加上一个缓存的功能,所谓的缓存不就是new一个byte数组
public class BufferedInputStream extends FilterInputStream {
    private static int defaultBufferSize = 8192;                 //默认缓存的大小
    protected volatile byte buf[];    //内部的缓存（数组）volatile修饰，保证不同的线程总是看到某个成员变量的同一个值
    protected int count; //buffer的大小，表示当前缓冲区内总共有多少有效数据
    protected int pos; //buffer中cursor的位置，即byte数组的当前下标，下次读取从该位置读取
    protected int markpos = -1;                                 //mark的位置
    protected int marklimit;    //mark的范围，最多能mark的字节长度，也就是从mark位置到当前pos的最大长度，作为参数传入
 
//原子性更新。和一致性编程相关
    private static final
        AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =
        AtomicReferenceFieldUpdater.newUpdater (BufferedInputStream.class,  byte[].class, "buf");
 
    private InputStream getInIfOpen() throws IOException {  //检查输入流是否关闭，同时返回被包装流
        InputStream input = in;
     if (input == null)    throw new IOException("Stream closed");
        return input;
    }
 
    private byte[] getBufIfOpen() throws IOException {             //检查buffer的状态，同时返回缓存
        byte[] buffer = buf;
     if (buffer == null)   throw new IOException("Stream closed");         //不太可能发生的状态
        return buffer;
    }
 
    public BufferedInputStream(InputStream in) {                //构造器
         this(in, defaultBufferSize);    //指定默认长度（defaultBufferSize）为buffer的长度
    }
 
    public BufferedInputStream(InputStream in, int size) {            //构造器
         super(in);
        if (size <= 0) {    //检查size参数，
            throw new IllegalArgumentException("Buffer size <= 0");
        }
         buf = new byte[size]; //创建指定长度的buffer，这就缓存！
    }
 
//从流中读取数据，填充如缓存中。构造函数开辟了缓存，都是空值，需要方法来填充它们。
    private void fill() throws IOException {
        byte[] buffer = getBufIfOpen();             //得到buffer
//buffer没有被mark，也就是说没有被调用mark方法
     if (markpos < 0) 
         pos = 0; //mark位置小于0，此时pos为0
    // buffer被mark的情况
     else if (pos >= buffer.length) //pos大于buffer的长度,读到buffer的最后
         if (markpos > 0) {    //有mark，将mark-pos段的数组保留
         int sz = pos - markpos;            
         System.arraycopy(buffer, markpos, buffer, 0, sz);
         pos = sz;
         markpos = 0;
         } else if (buffer.length >= marklimit) {    //buffer的长度大于marklimit时，mark失效
         markpos = -1;                        
         pos = 0;                             //丢弃buffer中的内容
         } else {//buffer的长度小于marklimit时对buffer扩容
         int nsz = pos * 2;
         if (nsz > marklimit)         nsz = marklimit;//扩容为原来的2倍，太大则为marklimit大小
         byte nbuf[] = new byte[nsz];            
         System.arraycopy(buffer, 0, nbuf, 0, pos);     //将buffer中的字节拷贝如扩容后的buf中
                if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {//在buffer在被操作时，不能取代此buffer
                    throw new IOException("Stream closed");
                }
                buffer = nbuf; //将新buf赋值给buffer
         }
        count = pos;
     int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
        if (n > 0)     count = n + pos;
    }
 
    public synchronized int read() throws IOException { //读取下一个字节
     if (pos >= count) {                             //到达buffer的末端
         fill();//就从流中读取数据，填充buffer
         if (pos >= count)     return -1; //读过一次，没有数据则返回-1
     }
     return getBufIfOpen()[pos++] & 0xff;    //返回buffer中下一个位置的字节
    }
 
    private int read1(byte[] b, int off, int len) throws IOException {    //将数据从流中读入buffer中
     int avail = count - pos;    //buffer中还剩的可读字符
     if (avail <= 0) {//buffer中没有可以读取的数据时
         if (len >= getBufIfOpen().length && markpos < 0) {    
         return getInIfOpen().read(b, off, len); //将输入流中的字节读入b中
         }
         fill();//填充
         avail = count - pos;
         if (avail <= 0) return -1;
     }
     int cnt = (avail < len) ? avail : len; //从流中读取后，检查可以读取的数目
     System.arraycopy(getBufIfOpen(), pos, b, off, cnt);    //将当前buffer中的字节放入b的末端
     pos += cnt;
     return cnt;
    }
 
 
// byte b[]调用者提供，调用者要使用的也是它。
    public synchronized int read(byte b[], int off, int len)throws IOException {
        getBufIfOpen();                                      // 检查buffer是否open
        if ((off | len | (off + len) | (b.length - (off + len))) < 0) {//检查输入参数是否正确
         throw new IndexOutOfBoundsException();
     } else if (len == 0) {
            return 0;
        }
     int n = 0;
        for (;;) {
            int nread = read1(b, off + n, len - n);
            if (nread <= 0)     return (n == 0) ? nread : n;
            n += nread;
            if (n >= len)     return n;
            // if not closed but no bytes available, return
            InputStream input = in;
            if (input != null && input.available() <= 0)     return n;
        }
    }
 
 
    public synchronized long skip(long n) throws IOException {
        getBufIfOpen();                      // 检查buffer是否关闭
     if (n <= 0) {    return 0;     }         //检查输入参数是否正确
     long avail = count - pos;              //buffered中可以读取字节的数目
        if (avail <= 0) {                     //可以读取的小于0，则从流中读取
            if (markpos <0)  return getInIfOpen().skip(n); //mark小于0，则mark在流中      
            fill();                         // 从流中读取数据，填充缓冲区。
            avail = count - pos;                 //可以读的取字节为buffer的容量减当前位置
            if (avail <= 0)     return 0;
        }       
        long skipped = (avail < n) ? avail : n;    
        pos += skipped;                     //当前位置改变
        return skipped;
    }
 
    public synchronized int available() throws IOException {
         return getInIfOpen().available() + (count - pos);        
    }
     //该方法不会block！返回流中可以读取的字节的数目。
     //该方法的返回值为缓存中的可读字节数目加流中可读字节数目的和
 
    public synchronized void mark(int readlimit) {     //当前位置处为mark位置
     marklimit = readlimit;
     markpos = pos;
    }
 
    public synchronized void reset() throws IOException {
        getBufIfOpen(); // 缓冲去关闭了，肯定就抛出异常！程序设计中经常的手段
         if (markpos < 0)        throw new IOException("Resetting to invalid mark");
         pos = markpos;
    }
 
    public boolean markSupported() {         //该流和ByteArrayInputStream一样都支持mark
         return true;
    }
 
     //关闭当前流同时释放相应的系统资源。
    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()
        }
    }
}

fill()---> 从字面理解就是填充的意思，实际上是从真正的输入流中读取一些新数据放入缓冲内存中，之后直到缓冲内存中的数据读完前都不会再从真正的流中读取数据。
网上对这个方法的分析：
　　　　　　　　　　普通的情况：

　　

　　　　　　　　　　有mark的情况：

 

普通的练习,复制文件：

first:

private void copyFile(String fromPath, String toPath) throws IOException{
        // input
        File fromFile = new File(fromPath);
        InputStream is = new FileInputStream(fromFile);
        BufferedInputStream bis = new BufferedInputStream(is);
        // output
        File toFile = new File(toPath);
        OutputStream os = new FileOutputStream(toFile);
        BufferedOutputStream bos = new BufferedOutputStream(os);
        // transfer station 
        byte b[] = new byte[(int)fromFile.length()] ;
        while(bis.read(b, 0, b.length) != -1){
            bos.write(b, 0, b.length);
        }
        bis.close();
        bos.close();
    }

second:

public static void copy()   throws IOException  
    {  
        BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("d:/我的文档/123.txt"));  
        BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("d:/我的文档/txt.txt"));  
  
        int by = 0;  
        while ((by=bufis.read()) != -1)  
        {  
            bufos.write(by);  
        }  
  
        bufos.close();  
        bufis.close();  
    }

总结：

理解还不是很深刻，对它的实现的理解还有很多不理解的地方，还需要继续学习。

加油吧！

----------------------------------------------------------------------

努力不一定成功，但不努力肯定不会成功。
共勉。