1 protected volatile InputStream in;
2 protected FilterInputStream(InputStream in) {
3     this.in = in;
4 }

 1 protected volatile byte buf[];
 2 private static int defaultBufferSize = 8192;
 3 public BufferedInputStream(InputStream in, int size) {
 4     super(in);
 5     if (size <= 0) {
 6         throw new IllegalArgumentException("Buffer size <= 0");
 7     }
 8     buf = new byte[size];
 9 }
10 public BufferedInputStream(InputStream in) {
11     this(in, defaultBufferSize);
12 }

1 protected int count;
2 protected int pos;
3 protected int markpos = -1;
4 protected int marklimit;

1 public synchronized int read() throws IOException {
2     if (pos >= count) {
3         fill();
4         if (pos >= count)
5         return -1;
6     }
7     return getBufIfOpen()[pos++] & 0xff;
8 }

 1     /**
 2      * Fills the buffer with more data, taking into account
 3      * shuffling and other tricks for dealing with marks.
 4      * Assumes that it is being called by a synchronized method.
 5      * This method also assumes that all data has already been read in,
 6      * hence pos > count.
 7      */
 8     private void fill() throws IOException {
 9         byte[] buffer = getBufIfOpen();
10         if (markpos < 0)
11             pos = 0;            /* no mark: throw away the buffer */
12         else if (pos >= buffer.length)  /* no room left in buffer */
13             if (markpos > 0) {  /* can throw away early part of the buffer */
14                 int sz = pos - markpos;
15                 System.arraycopy(buffer, markpos, buffer, 0, sz);
16                 pos = sz;
17                 markpos = 0;
18             } else if (buffer.length >= marklimit) {
19                 markpos = -1;   /* buffer got too big, invalidate mark */
20                 pos = 0;        /* drop buffer contents */
21             } else if (buffer.length >= MAX_BUFFER_SIZE) {
22                 throw new OutOfMemoryError("Required array size too large");
23             } else {            /* grow buffer */
24                 int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
25                         pos * 2 : MAX_BUFFER_SIZE;
26                 if (nsz > marklimit)
27                     nsz = marklimit;
28                 byte nbuf[] = new byte[nsz];
29                 System.arraycopy(buffer, 0, nbuf, 0, pos);
30                 if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
31                     // Can‘t replace buf if there was an async close.
32                     // Note: This would need to be changed if fill()
33                     // is ever made accessible to multiple threads.
34                     // But for now, the only way CAS can fail is via close.
35                     // assert buf == null;
36                     throw new IOException("Stream closed");
37                 }
38                 buffer = nbuf;
39             }
40         count = pos;
41         int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
42         if (n > 0)
43             count = n + pos;
44     }

    /**
     * See the general contract of the <code>mark</code>
     * method of <code>InputStream</code>.
     *
     * @param   readlimit   the maximum limit of bytes that can be read before
     *                      the mark position becomes invalid.
     * @see     java.io.BufferedInputStream#reset()
     */
    public synchronized void mark(int readlimit) {
        marklimit = readlimit;
        markpos = pos;
    }

    /**
     * See the general contract of the <code>reset</code>
     * method of <code>InputStream</code>.
     * <p>
     * If <code>markpos</code> is <code>-1</code>
     * (no mark has been set or the mark has been
     * invalidated), an <code>IOException</code>
     * is thrown. Otherwise, <code>pos</code> is
     * set equal to <code>markpos</code>.
     *
     * @exception  IOException  if this stream has not been marked or,
     *                  if the mark has been invalidated, or the stream
     *                  has been closed by invoking its {@link #close()}
     *                  method, or an I/O error occurs.
     * @see        java.io.BufferedInputStream#mark(int)
     */
    public synchronized void reset() throws IOException {
        getBufIfOpen(); // Cause exception if closed
        if (markpos < 0)
            throw new IOException("Resetting to invalid mark");
        pos = markpos;
    }

1 return getBufIfOpen()[pos++] & 0xff;

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()
}

protected volatile byte buf[];
private static final 
        AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater = 
        AtomicReferenceFieldUpdater.newUpdater
        (BufferedInputStream.class,  byte[].class, "buf");

 1 package java.io;
 2 
 3 public class BufferedOutputStream extends FilterOutputStream {
 4     // 保存“缓冲输出流”数据的字节数组
 5     protected byte buf[];
 6 
 7     // 缓冲中数据的大小
 8     protected int count;
 9 
10     // 构造函数：新建字节数组大小为8192的“缓冲输出流”
11     public BufferedOutputStream(OutputStream out) {
12         this(out, 8192);
13     }
14 
15     // 构造函数：新建字节数组大小为size的“缓冲输出流”
16     public BufferedOutputStream(OutputStream out, int size) {
17         super(out);
18         if (size <= 0) {
19             throw new IllegalArgumentException("Buffer size <= 0");
20         }
21         buf = new byte[size];
22     }
23 
24     // 将缓冲数据都写入到输出流中
25     private void flushBuffer() throws IOException {
26         if (count > 0) {
27             out.write(buf, 0, count);
28             count = 0;
29         }
30     }
31 
32     // 将“数据b(转换成字节类型)”写入到输出流中
33     public synchronized void write(int b) throws IOException {
34         // 若缓冲已满，则先将缓冲数据写入到输出流中。
35         if (count >= buf.length) {
36             flushBuffer();
37         }
38         // 将“数据b”写入到缓冲中
39         buf[count++] = (byte)b;
40     }
41 
42     public synchronized void write(byte b[], int off, int len) throws IOException {
43         // 若“写入长度”大于“缓冲区大小”，则先将缓冲中的数据写入到输出流，然后直接将数组b写入到输出流中
44         if (len >= buf.length) {
45             flushBuffer();
46             out.write(b, off, len);
47             return;
48         }
49         // 若“剩余的缓冲空间 不足以 存储即将写入的数据”，则先将缓冲中的数据写入到输出流中
50         if (len > buf.length - count) {
51             flushBuffer();
52         }
53         System.arraycopy(b, off, buf, count, len);
54         count += len;
55     }
56 
57     // 将“缓冲数据”写入到输出流中
58     public synchronized void flush() throws IOException {
59         flushBuffer();
60         out.flush();
61     }
62 }