Poison

ClassLoader.registerAsParallelCapable()

发表于

最近在做 Java Agent 的相关开发，参考部分开源代码实现的自定义类加载器实现时，部分类加载器实现含有以下静态块：

1
2
3
static {
    ClassLoader.registerAsParallelCapable();
}

该方法的实现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/**
 * Registers the caller as parallel capable.
 * The registration succeeds if and only if all of the following
 * conditions are met:
 * <ol>
 * <li> no instance of the caller has been created</li>
 * <li> all of the super classes (except class Object) of the caller are
 * registered as parallel capable</li>
 * </ol>
 * <p>Note that once a class loader is registered as parallel capable, there
 * is no way to change it back.</p>
 *
 * @return  true if the caller is successfully registered as
 *          parallel capable and false if otherwise.
 *
 * @since   1.7
 */
@CallerSensitive
protected static boolean registerAsParallelCapable() {
    Class<? extends ClassLoader> callerClass =
        Reflection.getCallerClass().asSubclass(ClassLoader.class);
    return ParallelLoaders.register(callerClass);
}

可以看出是 JDK 7 引入的，再看看 ParallelLoaders 的代码：

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
/**
 * Encapsulates the set of parallel capable loader types.
 */
private static class ParallelLoaders {
    private ParallelLoaders() {}

    // the set of parallel capable loader types
    private static final Set<Class<? extends ClassLoader>> loaderTypes =
        Collections.newSetFromMap(
            new WeakHashMap<Class<? extends ClassLoader>, Boolean>());
    static {
        synchronized (loaderTypes) { loaderTypes.add(ClassLoader.class); }
    }

    /**
     * Registers the given class loader type as parallel capabale.
     * Returns {@code true} is successfully registered; {@code false} if
     * loader's super class is not registered.
     */
    static boolean register(Class<? extends ClassLoader> c) {
        synchronized (loaderTypes) {
            if (loaderTypes.contains(c.getSuperclass())) {
                // register the class loader as parallel capable
                // if and only if all of its super classes are.
                // Note: given current classloading sequence, if
                // the immediate super class is parallel capable,
                // all the super classes higher up must be too.
                loaderTypes.add(c);
                return true;
            } else {
                return false;
            }
        }
    }

    /**
     * Returns {@code true} if the given class loader type is
     * registered as parallel capable.
     */
    static boolean isRegistered(Class<? extends ClassLoader> c) {
        synchronized (loaderTypes) {
            return loaderTypes.contains(c);
        }
    }
}

可以看出 ParallelLoaders.register(callerClass) 在超类具有并行加载能力时将当前类加载器往 loaderTypes 中添加，以使当前类加载器具有并行加载能力，其中 ParallelLoaders.isRegistered 方法在 ClassLoader 的构造函数中被调用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Maps class name to the corresponding lock object when the current
// class loader is parallel capable.
// Note: VM also uses this field to decide if the current class loader
// is parallel capable and the appropriate lock object for class loading.
private final ConcurrentHashMap<String, Object> parallelLockMap;

private ClassLoader(Void unused, ClassLoader parent) {
    this.parent = parent;
    if (ParallelLoaders.isRegistered(this.getClass())) {
        parallelLockMap = new ConcurrentHashMap<>();
        package2certs = new ConcurrentHashMap<>();
        assertionLock = new Object();
    } else {
        // no finer-grained lock; lock on the classloader instance
        parallelLockMap = null;
        package2certs = new Hashtable<>();
        assertionLock = this;
    }
}

根据如上代码可以看出如果 classLoader 被注册为了并行类加载器，则对 parallelLockMap 字段进行了初始化，否则使用 classloader 实例作为锁。其中对 parallelLockMap 主要使用方法如下：

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
/**
 * Returns the lock object for class loading operations.
 * For backward compatibility, the default implementation of this method
 * behaves as follows. If this ClassLoader object is registered as
 * parallel capable, the method returns a dedicated object associated
 * with the specified class name. Otherwise, the method returns this
 * ClassLoader object.
 *
 * @param  className
 *         The name of the to-be-loaded class
 *
 * @return the lock for class loading operations
 *
 * @throws NullPointerException
 *         If registered as parallel capable and <tt>className</tt> is null
 *
 * @see #loadClass(String, boolean)
 *
 * @since  1.7
 */
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;
}

当 parallelLockMap 为空即该 classLoader 不具有并行类加载能力时，直接返回当前 classLoader 实例作为锁的对象，当 parallelLockMap 不为空时，使用需要加载类的 className 作为 key，并新创建了一个 Object （如果创建过就使用之前创建的 Object）作为锁的对象，getClassLoadingLock 方法在 loadClass 方法中被调用，其中 loadClass 方法代码如下：

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
68
69
70
71
72
73
74
75
76
77
78
/**
 * Loads the class with the specified <a href="#name">binary name</a>.  The
 * default implementation of this method searches for classes in the
 * following order:
 *
 * <ol>
 *
 *   <li><p> Invoke {@link #findLoadedClass(String)} to check if the class
 *   has already been loaded.  </p></li>
 *
 *   <li><p> Invoke the {@link #loadClass(String) <tt>loadClass</tt>} method
 *   on the parent class loader.  If the parent is <tt>null</tt> the class
 *   loader built-in to the virtual machine is used, instead.  </p></li>
 *
 *   <li><p> Invoke the {@link #findClass(String)} method to find the
 *   class.  </p></li>
 *
 * </ol>
 *
 * <p> If the class was found using the above steps, and the
 * <tt>resolve</tt> flag is true, this method will then invoke the {@link
 * #resolveClass(Class)} method on the resulting <tt>Class</tt> object.
 *
 * <p> Subclasses of <tt>ClassLoader</tt> are encouraged to override {@link
 * #findClass(String)}, rather than this method.  </p>
 *
 * <p> Unless overridden, this method synchronizes on the result of
 * {@link #getClassLoadingLock <tt>getClassLoadingLock</tt>} method
 * during the entire class loading process.
 *
 * @param  name
 *         The <a href="#name">binary name</a> of the class
 *
 * @param  resolve
 *         If <tt>true</tt> then resolve the class
 *
 * @return  The resulting <tt>Class</tt> object
 *
 * @throws  ClassNotFoundException
 *          If the class could not be found
 */
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 {
                if (parent != null) {
                    c = parent.loadClass(name, false);
                } else {
                    c = findBootstrapClassOrNull(name);
                }
            } catch (ClassNotFoundException e) {
                // ClassNotFoundException thrown if class not found
                // from the non-null parent class loader
            }

            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;
    }
}

getClassLoadingLock 方法的返回值被 synchronized 关键字所使用，以上就是支持并行类加载的类加载器的不同之处，但是为什么要这样实现呢，关于这一点，可以参考：Multithreaded Custom Class Loaders in Java SE 7，该文档解释了为何引入该项特性，其中有一段提到：

Custom class loaders will not run into deadlocks if they adhere to an acyclic class loader delegation model. Acyclic delegation is what the architects of ClassLoader envisioned.

自定义类加载器如果遵循无环的类加载委托模型则不会导致死锁，无环的委托模型是 ClassLoader 的架构师所设想的。

In earlier releases of the Java platform, multithreaded custom class loaders could deadlock when they did not have an acyclic delegation model.

在早期的 Java 平台中，多线程自定义类加载器当没有遵循无环的委托模型时可能导致死锁。

该文档详细描述了自定义类加载器没有遵循无环委托模型时可能导致死锁的问题并给出了解决方案，即在 ClassLoader 及需要加载的 className 上进行同步，以解决可能存在的死锁问题。

Reference

Class Loader API Modifications for Deadlock Fix