HttpURLConnection

1 public BufferedInputStream(InputStream in, int size) {  
2     super(in);  
3         if (size <= 0) {  
4             throw new IllegalArgumentException("Buffer size <= 0");  
5         }  
6     buf = new byte[size];  
7 }  

 1 private void fill() throws IOException {
 2         byte[] buffer = getBufIfOpen();
 3     if (markpos < 0) ｛
 4           /*如果不存在标记位置（即没有需要进行reset的位置需求）
 5             则可以进行大胆地直接重置pos标识下一可读取位置,但是这样
 6             不是会读取到以前的旧数据吗？不用担心，在后面的代码里☆会实现输入流的新 
 7             数据填充*/
 8         pos = 0;        
 9     ｝else if (pos >= buffer.length)｛
10        /* 位置大于缓冲区长度，这里表示已经没有可用空间了 */
11         if (markpos > 0) {    
12              /* 表示存在mark位置，则要对mark位置到pos位置的数据予以保留，
13                 以确保后面如果调用reset()重新从mark位置读取会取得成功*/
14         int sz = pos - markpos;
15                 /*该实现是通过将缓冲区域中markpos至pos部分的移至缓冲区头部实现*/
16         System.arraycopy(buffer, markpos, buffer, 0, sz);
17         pos = sz;
18         markpos = 0;
19         } else if (buffer.length >= marklimit) {
20                 /* 如果缓冲区已经足够大，可以容纳marklimit，则直接重置*/
21                 markpos = -1;    
22         pos = 0;/* 丢弃所有的缓冲区内容 */
23         } else {        
24                 /* 如果缓冲区还能增长的空间，则进行缓冲区扩容*/
25         int nsz = pos * 2;
26                 /*新的缓冲区大小设置成满足最大标记极限即可*/
27         if (nsz > marklimit)
28             nsz = marklimit;
29         byte nbuf[] = new byte[nsz];
30                 //将原来的较小的缓冲内容COPY至增容的新缓冲区中
31         System.arraycopy(buffer, 0, nbuf, 0, pos);
32                 //这里使用了原子变量引用更新，确保多线程环境下内存的可见性
33                 if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
34                     // Can‘t replace buf if there was an async close.
35                     // Note: This would need to be changed if fill()
36                     // is ever made accessible to multiple threads.
37                     // But for now, the only way CAS can fail is via close.
38                     // assert buf == null;
39                     throw new IOException("Stream closed");
40                 }
41                 buffer = nbuf;
42         }
43         count = pos;
44         //从原始输入流中读取数据，填充缓冲区
45     int n = getInIfOpen().read(buffer, pos, buffer.length - pos);
46         //根据实际读取的字节数更新缓冲区中可用字节数
47         if (n > 0)
48             count = n + pos;
49     }

 1 public synchronized int read() throws IOException {
 2     if (pos >= count) {
 3            /*表示读取位置已经超过了缓冲区可用范围，则对缓冲区进行重新填充*/
 4         fill();
 5            /*当填充后再次读取时发现没有数据可读，证明读到了流末尾*/
 6         if (pos >= count)
 7         return -1;
 8     }
 9         /*这里表示读取位置尚未超过缓冲区有效范围，直接返回缓冲区内容*/
10     return getBufIfOpen()[pos++] & 0xff;
11 }

 1 private int read1(byte[] b, int off, int len) throws IOException {
 2     int avail = count - pos;
 3     if (avail <= 0) {
 4         /*这里使用了一个巧妙的机制，如果读取的长度大于缓冲区的长度
 5               并且没有markpos，则直接从原始输入流中进行读取，从而避免无谓的
 6               COPY（从原始输入流至缓冲区，读取缓冲区全部数据，清空缓冲区，
 7               重新填入原始输入流数据）*/
 8         if (len >= getBufIfOpen().length && markpos < 0) {
 9         return getInIfOpen().read(b, off, len);
10         }
11             /*当无数据可读时，从原始流中载入数据到缓冲区中*/
12         fill();
13         avail = count - pos;
14         if (avail <= 0) return -1;
15     }
16     int cnt = (avail < len) ? avail : len;
17         /*从缓冲区中读取数据，返回实际读取到的大小*/
18     System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
19     pos += cnt;
20     return cnt;
21     }

 1 public synchronized int read(byte b[], int off, int len)
 2     throws IOException
 3     {
 4         getBufIfOpen(); // Check for closed stream
 5         if ((off | len | (off + len) | (b.length - (off + len))) < 0) {
 6         throw new IndexOutOfBoundsException();
 7     } else if (len == 0) {
 8             return 0;
 9         }
10 
11     int n = 0;
12         for (;;) {
13             int nread = read1(b, off + n, len - n);
14             if (nread <= 0) 
15                 return (n == 0) ? nread : n;
16             n += nread;
17             if (n >= len)
18                 return n;
19             // if not closed but no bytes available, return
20             InputStream input = in;
21             if (input != null && input.available() <= 0)
22                 return n;
23         }
24     }

 1 public synchronized long skip(long n) throws IOException {
 2         getBufIfOpen(); // Check for closed stream
 3     if (n <= 0) {
 4         return 0;
 5     }
 6     long avail = count - pos;
 7      
 8         if (avail <= 0) {
 9             // If no mark position set then don‘t keep in buffer
10             //从上面的注释可以知道，这也是一个巧妙的方法，如果没有mark标记，
11             // 则直接从原始输入流中skip
12             if (markpos <0) 
13                 return getInIfOpen().skip(n);
14             
15             // Fill in buffer to save bytes for reset
16             fill();
17             avail = count - pos;
18             if (avail <= 0)
19                 return 0;
20         }
21         //该方法的实现为尽量原则，不保证一定略过规定的字节数。
22         long skipped = (avail < n) ? avail : n;
23         pos += skipped;
24         return skipped;
25     }

1 public synchronized int available() throws IOException {
2     return getInIfOpen().available() + (count - pos);
3     }

1 public synchronized void reset() throws IOException {
2         getBufIfOpen(); // Cause exception if closed
3     if (markpos < 0)
4         throw new IOException("Resetting to invalid mark");
5     pos = markpos;
6     }

1 public synchronized void reset() throws IOException {
2         getBufIfOpen(); // Cause exception if closed
3     if (markpos < 0)
4         throw new IOException("Resetting to invalid mark");
5     pos = markpos;
6     }

 1 public void close() throws IOException {
 2         byte[] buffer;
 3         while ( (buffer = buf) != null) {
 4             if (bufUpdater.compareAndSet(this, buffer, null)) {
 5                 InputStream input = in;
 6                 in = null;
 7                 if (input != null)
 8                     input.close();
 9                 return;
10             }
11             // Else retry in case a new buf was CASed in fill()
12         }
13     }