基于源码深入了解Java的类加载机制(JDK8和JDK11双版本)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public Class<?> loadClass(String name) throws ClassNotFoundException {
	return loadClass(name, false);
}

protected Class<?> loadClass(String name, boolean resolve)
	throws ClassNotFoundException
{
	// loadClass() 方法是通过 sycchronized 关键字来保证线程安全性的
	// 每个 class name 会对应1个锁
	// 若多个线程同时加载 class name 相同的类，因为锁的存在，仅有1个线程会获得执行
	// 若多个线程同时加载 class name 不同的类，因为各线程持有的锁是不同的，则线程间互不影响
	synchronized (getClassLoadingLock(name)) {
		// 首先检查一下该类是否已被加载过，若被加载过，则直接返回，避免重复加载
		Class<?> c = findLoadedClass(name);
		if (c == null) {
			long t0 = System.nanoTime();
			try {
				// 若父加载器存在，则由父加载器加载
				if (parent != null) {
					c = parent.loadClass(name, false);
				} else {
				// 若父加载器不存在，则由 Bootstrap ClassLoader 加载
				// 进入到这个分支，说明父加载器为 null
				// 父加载器为 null 的 ClassLoader 为扩展类加载器 (Extension ClassLoader)
					c = findBootstrapClassOrNull(name);
				}
			} catch (ClassNotFoundException e) {
				// ClassNotFoundException thrown if class not found
				// from the non-null parent class loader
			}
			// 若父加载器和 Bootstrap ClassLoader 均加载失败
			// 则调用当前类加载器的 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();
			}
		}
		// 是否加载之后进行解析
		if (resolve) {
			resolveClass(c);
		}
		return c;
	}
}

// 获取 class name 对应的类加载器锁
protected Object getClassLoadingLock(String className) {
	Object lock = this;
	if (parallelLockMap != null) {
		Object newLock = new Object();
		lock = parallelLockMap.putIfAbsent(className, newLock);
		if (lock == null) {
			lock = newLock;
		}
	}
	return lock;
}

1
2
3
4
5
6
7
8
9
10
private Class<?> findBootstrapClassOrNull(String name)
{
	if (!checkName(name)) return null;

	return findBootstrapClass(name);
}

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
static class ExtClassLoader extends URLClassLoader {
	private static volatile Launcher.ExtClassLoader instance;
	
	// 双重校验创建 ExtClassLoader 单例
	public static Launcher.ExtClassLoader getExtClassLoader() throws IOException {
		if (instance == null) {
			Class var0 = Launcher.ExtClassLoader.class;
			synchronized(Launcher.ExtClassLoader.class) {
				if (instance == null) {
					instance = createExtClassLoader();
				}
			}
		}

		return instance;
	}

	private static Launcher.ExtClassLoader createExtClassLoader() throws IOException {
		try {
			return (Launcher.ExtClassLoader)AccessController.doPrivileged(new PrivilegedExceptionAction<Launcher.ExtClassLoader>() {
				public Launcher.ExtClassLoader run() throws IOException {
					File[] var1 = Launcher.ExtClassLoader.getExtDirs();
					int var2 = var1.length;

					for(int var3 = 0; var3 < var2; ++var3) {
						MetaIndex.registerDirectory(var1[var3]);
					}
					// 最终通过构造器方法创建 ExtClassLoader 实例
					return new Launcher.ExtClassLoader(var1);
				}
			});
		} catch (PrivilegedActionException var1) {
			throw (IOException)var1.getException();
		}
	}

	void addExtURL(URL var1) {
		super.addURL(var1);
	}

	public ExtClassLoader(File[] var1) throws IOException {
		// 可以看到，ExtClassLoader 的父加载器为 null
		super(getExtURLs(var1), (ClassLoader)null, Launcher.factory);
		SharedSecrets.getJavaNetAccess().getURLClassPath(this).initLookupCache(this);
	}
	
	private static File[] getExtDirs() {
		// 扫描系统变量 java.ext.dirs 指定的路径
		String var0 = System.getProperty("java.ext.dirs");
		File[] var1;
		if (var0 != null) {
			StringTokenizer var2 = new StringTokenizer(var0, File.pathSeparator);
			int var3 = var2.countTokens();
			var1 = new File[var3];

			for(int var4 = 0; var4 < var3; ++var4) {
				var1[var4] = new File(var2.nextToken());
			}
		} else {
			var1 = new File[0];
		}

		return var1;
	}
	...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
static class AppClassLoader extends URLClassLoader {
	final URLClassPath ucp = SharedSecrets.getJavaNetAccess().getURLClassPath(this);

	public static ClassLoader getAppClassLoader(final ClassLoader var0) throws IOException {
		final String var1 = System.getProperty("java.class.path");
		final File[] var2 = var1 == null ? new File[0] : Launcher.getClassPath(var1);
		return (ClassLoader)AccessController.doPrivileged(new PrivilegedAction<Launcher.AppClassLoader>() {
			public Launcher.AppClassLoader run() {
				URL[] var1x = var1 == null ? new URL[0] : Launcher.pathToURLs(var2);
				// 这里的 var0 就是传入的 AppClassLoader 的父加载器
				return new Launcher.AppClassLoader(var1x, var0);
			}
		});
	}

	AppClassLoader(URL[] var1, ClassLoader var2) {
		super(var1, var2, Launcher.factory);
		this.ucp.initLookupCache(this);
	}

	public Class<?> loadClass(String var1, boolean var2) throws ClassNotFoundException {
		int var3 = var1.lastIndexOf(46);
		if (var3 != -1) {
			SecurityManager var4 = System.getSecurityManager();
			if (var4 != null) {
				var4.checkPackageAccess(var1.substring(0, var3));
			}
		}

		if (this.ucp.knownToNotExist(var1)) {
			Class var5 = this.findLoadedClass(var1);
			if (var5 != null) {
				if (var2) {
					this.resolveClass(var5);
				}

				return var5;
			} else {
				throw new ClassNotFoundException(var1);
			}
		} else {
			// 虽然复写了 loadClass() 方法，但本质上还是调用的 ClassLoader 类的 loadClass() 方法
			return super.loadClass(var1, var2);
		}
	}

1
2
3
4
5
6
// 构造函数会调用 getSystemClassLoader() 方法指定父加载器
// getSystemClassLoader() 方法的返回值为 ApplicationClassLoader
protected ClassLoader() {
	this(checkCreateClassLoader(), getSystemClassLoader());
}

1
2
3
4
5
6
7
8
9
10
11
12
private static class BootClassLoader extends BuiltinClassLoader {
	// 其父加载器为 null
	BootClassLoader(URLClassPath bcp) {
		super(null, null, bcp);
	}

	@Override
	protected Class<?> loadClassOrNull(String cn) {
		return JLA.findBootstrapClassOrNull(this, cn);
	}
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
private static class PlatformClassLoader extends BuiltinClassLoader {
	static {
		if (!ClassLoader.registerAsParallelCapable())
			throw new InternalError();
	}
	// Platform ClassLoader 的父加载器为 BootClassLoader
	PlatformClassLoader(BootClassLoader parent) {
		super("platform", parent, null);
	}

	private Package definePackage(String pn, Module module) {
		return JLA.definePackage(this, pn, module);
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
private static class AppClassLoader extends BuiltinClassLoader {
	static {
		if (!ClassLoader.registerAsParallelCapable())
			throw new InternalError();
	}

	final URLClassPath ucp;
	
	// AppClassLoader 的父加载器为 PlatformClassLoader
	AppClassLoader(PlatformClassLoader parent, URLClassPath ucp) {
		super("app", parent, ucp);
		this.ucp = ucp;
	}

	@Override
	protected Class<?> loadClass(String cn, boolean resolve)
		throws ClassNotFoundException
	{
		SecurityManager sm = System.getSecurityManager();
		if (sm != null) {
			int i = cn.lastIndexOf('.');
			if (i != -1) {
				sm.checkPackageAccess(cn.substring(0, i));
			}
		}
		// 调用父类 BuiltinClassLoader 的 loadClass() 方法
		return super.loadClass(cn, resolve);
	}

	...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
@Override
protected Class<?> loadClass(String cn, boolean resolve)
	throws ClassNotFoundException
{
	Class<?> c = loadClassOrNull(cn, resolve);
	if (c == null)
		throw new ClassNotFoundException(cn);
	return c;
}

protected Class<?> loadClassOrNull(String cn, boolean resolve) {
	synchronized (getClassLoadingLock(cn)) {
		// check if already loaded
		Class<?> c = findLoadedClass(cn);

		if (c == null) {

			// 判断该类归属于哪个系统模块
			LoadedModule loadedModule = findLoadedModule(cn);
			// 如果该类有指定模块
			if (loadedModule != null) {

				// package is in a module
				BuiltinClassLoader loader = loadedModule.loader();
				if (loader == this) {
					if (VM.isModuleSystemInited()) {
						c = findClassInModuleOrNull(loadedModule, cn);
					}
				} else {
					// delegate to the other loader
					c = loader.loadClassOrNull(cn);
				}
			// 如果该类没有指定模块
			} else {

				// 若存在父加载器，则交由父加载器负责加载
				if (parent != null) {
					c = parent.loadClassOrNull(cn);
				}

				// check class path
				if (c == null && hasClassPath() && VM.isModuleSystemInited()) {
					c = findClassOnClassPathOrNull(cn);
				}
			}

		}

		if (resolve && c != null)
			resolveClass(c);

		return c;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
protected ClassLoader() {
	this(checkCreateClassLoader(), null, getSystemClassLoader());
}

@CallerSensitive
public static ClassLoader getSystemClassLoader() {
	switch (VM.initLevel()) {
		case 0:
		case 1:
		case 2:
			// the system class loader is the built-in app class loader during startup
			return getBuiltinAppClassLoader();
		case 3:
			String msg = "getSystemClassLoader cannot be called during the system class loader instantiation";
			throw new IllegalStateException(msg);
		default:
			// system fully initialized
			assert VM.isBooted() && scl != null;
			SecurityManager sm = System.getSecurityManager();
			if (sm != null) {
				checkClassLoaderPermission(scl, Reflection.getCallerClass());
			}
			return scl;
	}
}

// 故自定义类加载器的父加载器为 AppClassLoader
static ClassLoader getBuiltinAppClassLoader() {
	return ClassLoaders.appClassLoader();
}

1
2
3
4
5
6
7
8
@Override
protected Class<?> loadClassOrNull(String cn) {
	return JLA.findBootstrapClassOrNull(this, cn);
}

// 最终是通过 JavaLangAccess 来实现类的加载
private static final JavaLangAccess JLA = SharedSecrets.getJavaLangAccess();