BufferedInputStream 源码分析

一、简介

　　BufferedInputStream会缓存一部分数据（默认8K），这个函数的作用就是读取更多的数据到缓存，必要的时候会扩大缓存的内容。

在该类中有几个重要的标志位:markpos,pos,count

　　【markpos的作用，marklength区域内的数据表示需要保留的数据，也就是在重置(reset 方法)buffer的时候，这部分数据是不会被删除的，强制要求保留。】　　

　　pos：

　　　　current position in the buffer, this is the index of the next character to be read from the buffer.

　　　　表示下一个即将读入的字符。

　　markpos:

　　　　The value of the pos field at the time the last mark method was called.

　　　　markpos 的数值等于上一次调用mark方法时候的pos位置。

     public synchronized void mark(int readlimit) {
         marklimit = readlimit;
         markpos = pos;
     }

　　　count:

　　　　　　可以使用的buffer

二、fill()函数

　　当pos>count的时候，调用该方法来扩容。它总会将预留空间的位置挪动到buffer的前端。

 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 {            /* 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;
     }

　　　　byte[] buffer = getBufIfOpen(); 获取当前buffer的引用

　　　　 if (markpos < 0)
            　　pos = 0;            /* no mark: throw away the buffer */ 整个buffer没有被标记过，也就是没有预留空间。

　　　　else if (pos >= buffer.length)  /* no room left in buffer */   (markpos >0 或=0 )有预留空间，而且没有剩余空间可用。

　　　　　　if (markpos > 0) {  /* can throw away early part of the buffer */  预留空间的起始位置不在buffer的开始位置
               　　 int sz = pos - markpos;    挪动预留空间
               　　 System.arraycopy(buffer, markpos, buffer, 0, sz);
              　　  pos = sz;
               　　 markpos = 0;

　　　　　　} else if (buffer.length >= marklimit) { 如果marklimit的值小于缓存的长度，说明buffer很大，从内存使用的角度考虑，此时不宜再增大缓存的容量，

　　　　　　　　　　　　　　　　　　　　　　　　　在这种情形下直接丢弃buf中的已有内容；
               　　 markpos = -1;   /* buffer got too big, invalidate mark */
                　　pos = 0;        /* drop buffer contents */

　　　　　} else {            /* grow buffer */ 2倍扩展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;
            }