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].
