水煮Java虚拟机 - ClassLoader源码分析(一)

/**
 * 委派的父类加载器
 */
private final ClassLoader parent;
/**
 * 类名对应的锁对象集合，当前类加载器具有并行能力时，将类名映射到相应的锁对象
 * VM会根据这个字段来判断当前类加载器是否具有并行能力
 */
private final ConcurrentHashMap<String, Object> parallelLockMap;
/**
 * 包名映射到 Certificate 的哈希集合
 */
private final Map <String, Certificate[]> package2certs;
/**
 * 无签名类共享的证书数组
 */
private static final Certificate[] nocerts = new Certificate[0];
/**
 * 记录当前类加载器加载的所有类，用于防止类被GC
 */
private final Vector<Class<?>> classes = new Vector<>();
/**
 * 默认的权限域
 */
private final ProtectionDomain defaultDomain =
    new ProtectionDomain(new CodeSource(null, (Certificate[]) null),
                         null, this, null);
/**
 * 当前类加载器加载的所有类对应的权限域
 */
private final Set<ProtectionDomain> domains;
/**
 * 当前类加载器定义的包对象集合，每个包会被映射成一个 Package 对象
 */
private final HashMap<String, Package> packages = new HashMap<>();
/**
 * 系统类加载器
 */
private static ClassLoader scl;
/**
 * 系统类加载器是否已设置标志
 */
private static boolean sclSet;
/**
 * 所有加载的本地库名称集合
 */
private static Vector<String> loadedLibraryNames = new Vector<>();
/**
 * 属于系统类的本地库集合
 */
private static Vector<NativeLibrary> systemNativeLibraries
    = new Vector<>();
/**
 * 与类加载器关联的本地库集合
 */
private Vector<NativeLibrary> nativeLibraries = new Vector<>();
/**
 * 正在被加载或卸载的本地库集合
 */
private static Stack<NativeLibrary> nativeLibraryContext = new Stack<>();
/**
 * 用户搜索路径
 */
private static String usr_paths[];
/**
 * 系统搜索路径
 */
private static String sys_paths[];
/**
 * 断言锁对象
 */
final Object assertionLock;
/**
 * 默认的断言检查状态
 */
private boolean defaultAssertionStatus = false;
/**
 * 包名映射到布尔型的断言状态，如果该字段为null，则将断言状态查询委托给VM
 */
private Map<String, Boolean> packageAssertionStatus = null;
/**
 * 类全限名映射到布尔型的断言状态，如果该字段为null，则将断言状态查询委托给VM
 */
Map<String, Boolean> classAssertionStatus = null;

private ClassLoader(Void unused, ClassLoader parent) {
    // 设置父类加载器
    this.parent = parent;
    // 判断该类加载器是否具有并行能力
    if (ParallelLoaders.isRegistered(this.getClass())) {
        parallelLockMap = new ConcurrentHashMap<>();
        package2certs = new ConcurrentHashMap<>();
        domains =
            Collections.synchronizedSet(new HashSet<ProtectionDomain>());
        assertionLock = new Object();
    } else {
        // no finer-grained lock; lock on the classloader instance
        // 无并行能力
        // 并行锁对象集合为null
        parallelLockMap = null;
        package2certs = new Hashtable<>();
        domains = new HashSet<>();
        assertionLock = this;
    }
}


protected ClassLoader(ClassLoader parent) {
    this(checkCreateClassLoader(), parent);
}


protected ClassLoader() {
    this(checkCreateClassLoader(), getSystemClassLoader());
}

/**
 * 加载指定名称的类
 *
 * @param name 类名称
 * @param resolve 是否需要解析
 * @return Class 对象
 * @throws ClassNotFoundException
 */
protected Class<?> loadClass(String name, boolean resolve)
    throws ClassNotFoundException
{
    // 获取指定类名对应的锁对象
    synchronized (getClassLoadingLock(name)) {
        // First, check if the class has already been loaded
        // 判断类是否已被加载
        Class<?> c = findLoadedClass(name);
        // 若类没有加载过
        if (c == null) {
            long t0 = System.nanoTime();
            try {
                // 判断父类加载器是否为null
                if (parent != null) {
                    // 父类加载器不为null，则委托给父类加载器加载
                    c = parent.loadClass(name, false);
                } else {
                    // 父类加载器为null，则委托给启动类加载器进行加载
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }


            // 若没有找到，则调用 findClass 方法查找此类
            if (c == null) {
                // If still not found, then invoke findClass in order
                // to find the class.
                long t1 = System.nanoTime();
                c = findClass(name);


                // this is the defining class loader; record the stats
                // 记录相应的时间数据
                sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                sun.misc.PerfCounter.getFindClasses().increment();
            }
        }
        // 判断是否类需要解析，若需要解析，则调用 resolveClass 方法
        if (resolve) {
            // 调用本地 resolveClass0 方法
            resolveClass(c);
        }
        return c;
    }
}


public Class<?> loadClass(String name) throws ClassNotFoundException {
    return loadClass(name, false);
}

protected final Class<?> findLoadedClass(String name) {
    if (!checkName(name))
        return null;
    // 调用本地方法
    return findLoadedClass0(name);
}


private native final Class<?> findLoadedClass0(String name);

private Class<?> findBootstrapClassOrNull(String name)
{
    // 检查类名是否符合规范
    if (!checkName(name)) return null;
    // 调用本地方法
    return findBootstrapClass(name);
}


// return null if not found
private native Class<?> findBootstrapClass(String name);

protected Class<?> findClass(String name) throws ClassNotFoundException {
    throw new ClassNotFoundException(name);
}

protected final Class<?> findSystemClass(String name)
    throws ClassNotFoundException
{
    // 获取系统类加载器
    ClassLoader system = getSystemClassLoader();
    // 若系统类加载器为空
    if (system == null) {
        // 判断类名是否符合规范
        if (!checkName(name))
            throw new ClassNotFoundException(name);
        // 从启动类加载器中查找指定类
        Class<?> cls = findBootstrapClass(name);
        if (cls == null) {
            // 未找到，直接抛出 ClassNotFoundException 异常
            throw new ClassNotFoundException(name);
        }
        return cls;
    }
    // 从系统类加载器中查找指定类
    return system.loadClass(name);
}