JDK源码阅读

JDK源码阅读(1)_简介+ java.io,jdkjava.io

1.简介

  针对这一个版块,主要做一个java8的源码阅读笔记。会对一些在javaWeb中应用比较广泛的java包进行精读,附上注释。对于容易混淆的知识点给出相应的对比分析。
  精读的源码顺序主要如下:

(1)第一部分:这部分是java开发的最常见包和类,要求精读:
  • java.io
  • java.lang
  • java.util

 

 (2)第二部分:这一部分是java
web开发的核心内容之一,要求要有深刻的理解。(包括了java的反射、网络io、非阻塞、并发编程)————某些大牛说,这一部分运用的好坏,掌握的水平高低,会决定一个java开发程员的档次:

 

  • java.lang.reflect
  • java.net
  • 官方澳门新永利下载,javax.net.*
  • java.nio
  • java.util.concurrent.*

 

  (3)第三部分:这一部分要求不高,进行简单泛读,能看懂、会用即可:

 

  • java,lang.annotation
  • javax.annotation
  • java.lang.ref
  • java.math
  • java.rmi.*
  • javax.rmi.*
  • java.security.*
  • javax.security.*
  • java.sql
  • javax.sql.*
  • javax.transaction.*
  • java.test
  • java.xml.*
  • org.w3c.dom.*
  • org.xml.sax.*
  • javax.crypto.*
  • javax.imageio.*
  • javax.jws.*
  • java.util.jar
  • java.util.logging
  • java.util.prefs
  • java.util.regex
  • java.util.zip

 

2.源码阅读:—— day1:(java.io_BufferedInputStream类)

(1)java.io——BufferedInputStream类

package java.io;
// java.io包,通过数据流、序列化和文件系统提供系统输入和输出
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
// 导入一个包,这个包运用到了一个多线程的原子更新器

  public class BufferedInputStream extends FilterInputStream {
    // 继承fileinputstream,为输入流添加一些功能;使用他防止每次读取时都得进行实际写操作;代表“使用缓冲区”

    private static int DEFAULT_BUFFER_SIZE = 8192;
  // 该变量定义了默认的缓冲大小 为8192;

    private static int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;
  // 最大长度依然是Integer.MAX_VALUE,并不是Integer.MAX_VALUE-8

    protected volatile byte buf[];
  // 存储数据的内部缓冲区数组,必要的时候可以用另外一个大小不同的数组替换它;
  // 注意volatile关键字表示不稳定变量,每次线程存取都应该直接从主程序中读取
  // (作用于多线程环境中)防止主程序值改变,影响其中某个线程的值无法匹配对应而出错;

    private static final
        AtomicReferenceFieldUpdater<BufferedInputStream, byte[]> bufUpdater =
        AtomicReferenceFieldUpdater.newUpdater
        (BufferedInputStream.class,  byte[].class, "buf");   
   // 缓存数组的一个原子更新器,该成员变量与buf数组的volatile关键字一起,实现buf数组的原子的更新;

    protected int count;
   // 比缓冲区中最后一个有效字节的索引大 1 的索引。此值始终处于 0 到 buf.length 的范围内;
   // 从 buf[0] 到 buf[count-1] 的元素包含从底层输入流中获取的缓冲输入数据。


    protected int pos;
  // pos = position ,缓冲区中的当前位置,这是将从buf数组中读取的下一个字符的索引;
  // 此值始终处于 0 到 count 的范围内。如果此值小于 count,则 buf[pos] 将作为下一个输入字节;
  // 如果此值等于 count,则下一次 read 或 skip 操作需要从包含的输入流中读取更多的字节。
  

    protected int markpos = -1;
  // 最后一次调用 mark 方法时 pos 字段的值为 -1; markpos的值始终处于 -1 到 pos 的范围内,
  // 如果输入流中没有被标记的位置,则此字段为 -1;如果输入流中有被标记的位置,则 buf[markpos] 将用作 reset 
  // 操作后的第一个输入字节。如果 markpos 不是 -1,则从位置 buf[markpos] 到 buf[pos-1] 之间的
  // 所有字节都必须保留在缓冲区数组中(尽管对 count、pos 和 markpos 的值进行适当调整后,这些字节可能移动到
  // 缓冲区数组中的其他位置);除非 pos 与 markpos 的差超过 marklimit,否则不能将其丢弃。


    protected int marklimit;
  // 调用 mark 方法后,在后续调用 reset 方法失败之前所允许的最大提前读取量。
  // 只要 pos 与 markpos 之差超过 marklimit,就可以通过将 markpos 设置为 -1 来删除该标记。

    private InputStream getInIfOpen() throws IOException {
        InputStream input = in;
        if (input == null)
            throw new IOException("Stream closed");
        return input;
    }
  // 如果输入流为 null ,则抛出传输流关闭“stream closed”的异常
  // 如果输入流不为 null ,则返回输入流,并将数据存储于 input 中


    private byte[] getBufIfOpen() throws IOException {
        byte[] buffer = buf;
        if (buffer == null)
            throw new IOException("Stream closed");
        return buffer;
    }
  // 创建一个输入流数组,用来保存其参数;当输入保存的参数数组为 null 时,抛出“stream closed”异常,
  // 当不为 null 时,直接返回数组 buffer ,并把输入流存储在数组之中;


    public BufferedInputStream(InputStream in) {
        this(in, DEFAULT_BUFFER_SIZE);           // java中,用this引用当前对象;
    }
  // 创建一个缓冲输入流 BufferedInputStream 并保存其数据,即输入流 in ,以便将来使用;
  // 回调缓冲输入流,并且保存其默认参数(缓冲输入流的长度);


    public BufferedInputStream(InputStream in, int size) {
        super(in);  // java类中使用super引用父类成分,InputStream是BufferedInputSream的父类;
        if (size <= 0) {
            throw new IllegalArgumentException("Buffer size <= 0");

        buf = new byte[size];
    }
  // 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数,即输入流 in,
  // 以便将来使用。创建一个长度为 size 的内部缓冲区数组并将其存储在 buf 中。


    private void fill() throws IOException {
        byte[] buffer = getBufIfOpen();
        if (markpos < 0)
            pos = 0;                        // 没有标记,总是指向缓冲流的初始位置;
        else if (pos >= buffer.length)      // 位置比缓冲区长度大,缓冲区中没有空间了;
            if (markpos > 0) {              // 抛出缓冲区的前半部分;
                int sz = pos - markpos;     // 字符串数据的长度;
                System.arraycopy(buffer, markpos, buffer, 0, sz);
                pos = sz;
                markpos = 0;                // 进行复制和初始化 pos 和 markpos;
            } else if (buffer.length >= marklimit) {
                markpos = -1;                // 缓冲区太大了,是一个无效的标志位,返回-1;
                pos = 0;                     // 降低缓冲区的内容;
            } else if (buffer.length >= MAX_BUFFER_SIZE) {
                throw new OutOfMemoryError("Required array size too large");
            } else {                        // 缓冲区进行拓展
                int nsz = (pos <= MAX_BUFFER_SIZE - pos) ?
                        pos * 2 : MAX_BUFFER_SIZE;
                if (nsz > marklimit)
                    nsz = marklimit;
                byte nbuf[] = new byte[nsz];
                System.arraycopy(buffer, 0, nbuf, 0, pos);
                if (!bufUpdater.compareAndSet(this, buffer, nbuf)) {
                    // 如果这里是不同步的关闭,则不能进行替换; 
                    // 注意:如果满了则需要进行拓展变换
                    // 对于多线程来说,永远不能达到
                    // 唯一的方式是通过关闭来结束
                    // 插入 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;    // 数量
    }



    public synchronized int read() throws IOException {
        if (pos >= count) {
            fill();           // 如果位置的值 pos 大于等于 长度数量 count;则调用fill()方法
            if (pos >= count)
                return -1;
        }
        return getBufIfOpen()[pos++] & 0xff;
    }



    // 将字符串读入到数组 array 之中,如果需要,最多进行 1 次;
    private int read1(byte[] b, int off, int len) throws IOException {
        int avail = count - pos;
        if (avail <= 0) {
       // 如果请求的长度至少和缓冲器一样的大,并且没有进行 mark/reset 操作;
       // 不要急于拷贝不要急于拷贝字节到本地缓冲器之中,如果这样,缓冲流将会无害级联;
            if (len >= getBufIfOpen().length && markpos < 0) {
                return getInIfOpen().read(b, off, len);
            }
            fill();
            avail = count - pos;
            if (avail <= 0) return -1;
        }
        int cnt = (avail < len) ? avail : len;
        System.arraycopy(getBufIfOpen(), pos, b, off, cnt);
        pos += cnt;
        return cnt;
    }



    // 以所给的偏移量开始,从输入字节流中,读取到具体字节流数组中;
    public synchronized int read(byte b[], int off, int len)
        throws IOException
    {
        getBufIfOpen();   // 检查缓冲流是否关闭;
        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==0返回nread,否则返回n;
            n += nread;
            if (n >= len)
                return n;
            // 如果输入流没有关闭,但是,已经没有字节可用,则直接返回;
            InputStream input = in;
            if (input != null && input.available() <= 0)
                return n;
        }
    }




    public synchronized long skip(long n) throws IOException {   // n为跳过字节数;
        getBufIfOpen();    // 检查字符流是否关闭
        if (n <= 0) {
            return 0;
        }
        long avail = count - pos;    //确定可用长度

        if (avail <= 0) {
            // 如果没有设定标志位置,也没有保存在 buffer 缓冲器中;
            if (markpos <0)
                return getInIfOpen().skip(n);

            // 填满 buffer 缓冲器,用以保存字节,等待重新设置;
            fill();
            avail = count - pos;
            if (avail <= 0)
                return 0;
        }

        long skipped = (avail < n) ? avail : n;  // 选择判断语句,跳过 avail 长度,或者跳过 n 长度;
        pos += skipped;
        return skipped;
    }



    //返回可以从该输入流中读取(或跳过)的字节数的估计数,而不需要对该输入流的方法的下一次调用进行阻塞。
    //下一个调用可能是同一个线程或另一个线程。此多字节的单个读或跳过不会阻塞,但可能读取或跳过更少字节。
    public synchronized int available() throws IOException {
        int n = count - pos;
        int avail = getInIfOpen().available();
        return n > (Integer.MAX_VALUE - avail)
                    ? Integer.MAX_VALUE
                    : n + avail;
    }


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


      // reset()重置方法;
    public synchronized void reset() throws IOException {
        getBufIfOpen();     // 如果缓冲流关闭会抛出异常;
        if (markpos < 0)    // 标志位置小于 0 ,会抛出异常;
            throw new IOException("Resetting to invalid mark");
        pos = markpos;
    }



    public boolean markSupported() {
        return true;    // 测试该输入流支持位置标志;
    }

    // 关闭此输入流并释放与流相关联的任何系统资源;
    // 一旦流已经关闭,进一步read(),available(),reset(),或skip()调用会抛出IOException;
   // 关闭先前关闭的流没有效果。
    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;
            }
           //其他的情况下,一个新的缓冲区被重新装入,调用fill()方法;
        }
    }
}

   这一块儿还算比较简单,看看api也差不多,有时间还是应该看看源码,会知其所以然~

java.io,jdkjava.io
1.简介
针对这一个版块,主要做一个java8的源码阅读笔记。会对一些在javaWeb中应用比较广泛的java包…

1.简介

  针对这一个版块,主要做一个java8的源码阅读笔记。会对一些在javaWeb中应用比较广泛的java包进行精读,附上注释。对于容易混淆的知识点给出相应的对比分析。
  精读的源码顺序主要如下:

(1)第一部分:这部分是java开发的最常见包和类,要求精读:
  • java.io
  • java.lang
  • java.util

 

 (2)第二部分:这一部分是java
web开发的核心内容之一,要求要有深刻的理解。(包括了java的反射、网络io、非阻塞、并发编程)————某些大牛说,这一部分运用的好坏,掌握的水平高低,会决定一个java开发程员的档次:

 

  • java.lang.reflect
  • java.net
  • javax.net.*
  • java.nio
  • java.util.concurrent.*

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注