Java 7 introduced support for parallel classloading. A description of that project and its goals can be found here:
http://openjdk.java.net/groups/core-libs/ClassLoaderProposal.html
The solution for parallel classloading was to add to each class loader a ConcurrentHashMap, referenced through a new field, parallelLockMap. This contains a mapping from class names to Objects to use as a classloading lock for that class name. This was then used in
the following way:
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;
}
}
Where getClassLoadingLock simply does:
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;
}
This approach is very inefficient in terms of
the space used per map and
the number of maps. First, there is a map per-classloader. As per
the code above under normal delegation
the current classloader creates and acquires a lock for
the given class, checks if it is already loaded, then asks its parent to load it;
the parent in turn creates another lock in its own map, checks if
the class is already loaded and then delegates to its parent and so on till
the boot loader is invoked for which there is no map and no lock. So even in
the simplest of applications, you will have two maps (in
the system and extensions loaders) for every class that has to be loaded transitively from
the application's main class. If you knew before hand which loader would actually load
the class
the locking would only need to be performed in that loader. As it stands
the locking is completely unnecessary for all classes loaded by
the boot loader.
Secondly, once loading has completed and findClass will return
the class,
the lock and
the map entry is completely unnecessary. But as it stands,
the lock objects and their associated entries are never removed from
the map.
It is worth understanding exactly what
the locking is intended to achieve, as this will help us understand potential remedies to
the above inefficiencies. Given this is
the support for parallel classloading,
the class loader itself is unlikely to need to guard against
concurrent load attempts - and if that were not
the case it is likely that
the classloader would need a different means to protect itself rather than a lock per class. Ultimately when a class file is located and
the class has to be loaded, defineClass is called which calls into
the VM -
the VM does not require any locking at
the Java level and uses its own mutexes for guarding its internal data structures (such as
the system dictionary).
The classloader locking is primarily needed to address
the following situation: if two threads attempt to load
the same class, one will initiate
the request through
the appropriate loader and eventually cause defineClass to be invoked. Meanwhile
the second attempt will block trying to acquire
the lock. Once
the class is loaded
the first thread will release
the lock, allowing
the second to acquire it.
The second thread then sees that
the class has now been loaded and will return that class. Neither thread can tell which did
the loading and they both continue successfully. Consider if no lock was acquired in
the classloader. Both threads will eventually locate
the file for
the class, read in
the bytecodes and call defineClass to actually load
the class. In this case
the first to call defineClass will succeed, while
the second will encounter an exception due to an attempted redefinition of an existing class. It is solely for this error condition that
the lock has to be used. (Note that parallel capable classloaders should not need to be doing old deadlock-avoidance tricks like doing a wait() on
the lock object\!).
There are a number of obvious things we can try to solve this problem and they basically take three forms:
Remove
the need for locking. This might be achieved by having a new version of defineClass which acts like defineClassIfNotPresent - simply returning an existing Class rather than triggering an exception.
Increase
the coarseness of locking to reduce
the number of lock objects and/or maps. For example, using a single shared lockMap instead of a per-loader lockMap.
Reduce
the lifetime of lock objects so that entries are removed from
the map when no longer needed (eg remove after loading, use weak references to
the lock objects and cleanup
the map periodically).
There are pros and cons to each of these approaches. Unfortunately a significant "con" is that
the API introduced in Java 7 to support parallel classloading has essentially mandated that these locks do in fact exist, and they are accessible to
the application code (indirectly through
the classloader if it exposes them - which a custom loader might do - and regardless they are accessible to custom classloaders). So while we can reason that we could do parallel classloading with no locking, we can not implement this without breaking
the specification for parallel classloading that was put in place for Java 7. Similarly we might reason that we can remove a mapping (and
the lock object) because
the class is already loaded, but this would again violate
the specification because it can be reasoned that
the following assertion should hold true:
Object lock1 = loader.getClassLoadingLock(name);
loader.loadClass(name);
Object lock2 = loader.getClassLoadingLock(name);
assert lock1 == lock2;
Without modifying
the specification, or at least doing some creative wordsmithing on it, options 1 and 3 are precluded. Even then there are caveats, for example if findLoadedClass is not atomic with respect to defineClass, then you can have
concurrent calls to findLoadedClass from different threads and that could be expensive (this is also an argument against moving findLoadedClass outside
the locked region - it may speed up
the common case where
the class is already loaded, but
the cost of re-executing after acquiring
the lock could be prohibitive. Even option 2 might need some wordsmithing on
the specification because
the specification for getClassLoadingLock states "returns a dedicated object associated with
the specified class name".
The question is, what does "dedicated" mean here? Does it mean unique in
the sense that
the returned object is only associated with
the given class in
the current loader? Or can
the object actually guard loading of multiple classes, possibly across different class loaders?
So it seems that changing
the specification will be inevitable if we wish to do something here. In which case lets go for something that more cleanly defines what we want to be doing: fully
concurrent class-loading.
Note: defineClassIfNotPresent is already implemented in
the VM as find_or_define_class. It is only used if
the AllowParallelDefineClass flag is set. This gives us an easy hook into existing VM mechanics.
Proposal: Fully
Concurrent ClassLoaders
The proposal is that we expand on
the notion of a parallel capable class loader and define a "fully
concurrent parallel capable class loader" or fully
concurrent loader, for short.
A fully
concurrent loader uses no synchronization in loadClass and
the VM uses
the "parallel define class" mechanism.
For a fully
concurrent loader getClassLoadingLock() can return null (or perhaps not - it doesn't matter as we won't use
the result anyway). At present we have not made any changes to this method.
All
the parallel capable JDK classloaders become fully
concurrent loaders. This doesn't require any code re-design as none of
the mechanisms implemented rely on
the per-name locking provided by
the parallelLockMap.
This seems to give us a path to remove all locking at
the Java level during classloading, while retaining full compatibility with Java 7 parallel capable loaders.
Fully
concurrent loaders will still encounter
the performance penalty associated with
concurrent attempts to find and prepare a class's bytecode for definition by
the VM. What this penalty is depends on
the number of
concurrent load attempts possible (a function of
the number of threads and
the application logic, and dependent on
the number of processors), and
the costs associated with finding and preparing
the bytecodes. This obviously has to be measured across a range of applications.
Preliminary webrevs:
http://cr.openjdk.java.net/~dholmes/concurrent-loaders/webrev.hotspot/
http://cr.openjdk.java.net/~dholmes/concurrent-loaders/webrev.jdk/
Please direct all comments to
the mailing list
[email protected].
