The section of code that does this classloader creation, has a great big

synchronized( loaderTable) {

...lots of code, including network access...

}

The code in the middle of the synchronized block is two fold. The first bit of code uses the synchronization to lock access to the map while unreferenced classloaders are scavenged from it. This work is going to be pretty quick on the average.

The second bit of code is work the ClassLoader is created. To create the ClassLoader there are several steps particular to that ClassLoader, but which shouldn't lock access to ClassLoaders which already exist.

However, the structure of the code, does just that. It needs to keep out multiple threads that are all trying to access the same codebase ClassLoader potentially.

The java.util.concurrent.ConcurrentHashMap class in JDK1.5 and later provides a really powerful mechanism for resolving certain concurrency issues with minimal locking. Below is a more complete representation of the structure.

synchronized( loaderTable ) {
    /*
     * Take this opportunity to remove from the table entries
     * whose weak references have been cleared.
     */
    Object ref;
    while ((ref = refQueue.poll()) != null) {
	if (ref instanceof LoaderKey) {
	    LoaderKey key = (LoaderKey) ref;
	    loaderTable.remove(key);
	} else if (ref instanceof LoaderEntry) {
	    LoaderEntry entry = (LoaderEntry) ref;
	    if (!entry.removed) {        // ignore entries removed below
		loaderTable.remove(entry.key);
	    }
	}
    }

    /*
     * Look up the codebase URL path and parent class loader pair
     * in the table of RMI class loaders.
     */
    LoaderKey key = new LoaderKey(urls, parent);
    LoaderEntry entry = (LoaderEntry) loaderTable.get(key);

    ClassLoader loader;
    if (entry == null ||
	(loader = (ClassLoader) entry.get()) == null)
    {
	/*
	 * If entry was in table but it's weak reference was cleared,
	 * remove it from the table and mark it as explicitly cleared,
	 * so that new matching entry that we put in the table will
	 * not be erroneously removed when this entry is processed
	 * from the weak reference queue.
	 */
	if (entry != null) {
	    loaderTable.remove(key);
	    entry.removed = true;
	}

	/*
	 * An existing loader with the given URL path and
	 * parent was not found.  Perform the following steps
	 * to obtain an appropriate loader:
	 * 
	 * Search for an ancestor of the parent class loader
	 * whose export urls match the parameter URL path
	 * 
	 * If a matching ancestor could not be found, create a
	 * new class loader instance for the requested
	 * codebase URL path and parent class loader.  The
	 * loader instance is created within an access control
	 * context restricted to the permissions necessary to
	 * load classes from its codebase URL path.
	 */
	loader = findOriginLoader(urls, parent);

	if (loader == null) {
	    loader = createClassLoader(urls, parent, requireDlPerm);
	}

	/*
	 * Finally, create an entry to hold the new loader with a
	 * weak reference and store it in the table with the key.
	 */
	entry = new LoaderEntry(key, loader);
	loaderTable.put(key, entry);
    }
    return loader;
}

// Declared somewhere at the class level.
int coreCount = ... 1 ...
int maxCount = ... 10 ...
int secondsAlive = ... 5 ...

// The queue for the class loader creation activities
LinkedBlockingQueue queue = new LinkedBlockingQueue();

// The executor using the queue.
ThreadPoolExecutor exec = new ThreadPoolExecutor( coreCount, maxCount,
	secondsAlive, TimeUnits.SECONDS, queue );

// The map holding the created futures.
ConcurrentHashMap> loaderFutures =
	new ConcurrentHashMap>();


// The replacement code structure...

/*
 * Look up the codebase URL path and parent class loader pair
 * in the table of RMI class loaders.
 */
final LoaderKey key = new LoaderKey(urls, parent);
final ClassLoader curLoader;

/*
 * Clean up the table and establish that we really don't
 * have a usable entry in this synchronized block.
 */
synchronized( loaderTable ) {
    /*
     * Take this opportunity to remove from the table entries
     * whose weak references have been cleared.
     */
    Object ref;
    while ((ref = refQueue.poll()) != null) {
        if (ref instanceof LoaderKey) {
            LoaderKey lkey = (LoaderKey) ref;
            loaderTable.remove(lkey);
            loaderFutures.remove( lkey );
        } else if (ref instanceof LoaderEntry) {
            LoaderEntry entry = (LoaderEntry) ref;
            if (!entry.removed) {    // ignore entries removed below
                loaderTable.remove(entry.key);
                loaderFutures.remove( entry.key );
            }
        }
    }

    /*
     * Get an atomic view of the current class loader's visability.
     * The contents of loaderTable and loaderFutures should mirror
     * each other.  We need a hard reference to the loader if it
     * is still alive, so that we don't lose it before the method
     * exits.  So, we grab that reference here, but we don't use it
     * anywhere as the 'curLoader' value, we just use that reference
     * to keep it alive until the Future.get() call returns the LoaderEntry
     * that references the ClassLoader, and we get the ClassLoader from
     * that LoaderEntry.
     */

    // Get any existing entry for this loader.
    final LoaderEntry lastEntry = (LoaderEntry) loaderTable.get(key);

    // Assign and hold a reference to the loader if present
    // so that GC doesn't take it away.
    if (lastEntry == null ||
            (curLoader = (ClassLoader) lastEntry.get()) == null) {

        // loader gone, remove future so that we will recreate/locate
        // the needed loader.
        loaderFutures.remove( key );

         /*
          * If entry was in table but it's weak reference was cleared,
          * remove it from the table and mark it as explicitly cleared,
          * so that new matching entry that we put in the table will
          * not be erroneously removed when this entry is processed
          * from the weak reference queue.
          */
        loaderTable.remove( key );
        if( lastEntry != null )
            lastEntry.removed = true;
    }
}

// If we get here, we know that we have to generate the class
// loader entry by either finding the existing one, or creating
// a new one.  The winning "putIfAbsent()" call below will designate
// the FutureTask that will be run to do the work.
FutureTaskfut = new FutureTask( 
    new Callable () {
        public LoaderEntry call() {

            /*
             * An existing loader with the given URL path and
             * parent was not found.  Perform the following steps
             * to obtain an appropriate loader:
             * 
             * Search for an ancestor of the parent class loader
             * whose export urls match the parameter URL path
             * 
             * If a matching ancestor could not be found, create a
             * new class loader instance for the requested
             * codebase URL path and parent class loader.  The
             * loader instance is created within an access control
             * context restricted to the permissions necessary to
             * load classes from its codebase URL path.
             */
            ClassLoader loader = findOriginLoader( urls, parent );

            if( loader == null ) {
                loader = createClassLoader(urls, parent, requireDlPerm);
            }

            /*
             * Finally, create an entry to hold the new loader with a
             * weak reference and store it in the table with the key.
             */
            LoaderEntry entry = new LoaderEntry(key, loader);
            synchronized( loaderTable ) {
                loaderTable.put(key, entry);
            }
            return entry;
        }
    }
);

// Try to add this FutureTask to the map.  If its already there, we get
// back the existing entry and can just get() that value.
// Otherwise, we need to queue the future to run, and then get the value
// returned.
FutureTask runfut = loaderFutures.putIfAbsent( key, fut );
try {
    if( runfut != null ) {
        if( logger.isLoggable( Level.FINER ) )
            logger.finer("waiting for loader for: "+key );
        return runfut.get().get();
    } else {
        if( logger.isLoggable( Level.FINER ) )
            logger.finer("starting loader task for: "+key );
        exec.execute( fut );
        if( logger.isLoggable( Level.FINER ) )
            logger.finer("getting loader for: "+key );
        return fut.get().get();
    }
} catch( InterruptedException ex ) {
    logger.log( Level.SEVERE, ex.toString(), ex );
    throw (NoClassDefFoundError)new NoClassDefFoundError(
        ex.toString() ).initCause( ex );
} catch( ExecutionException ex ) {
    logger.log( Level.SEVERE, ex.toString(), ex );
    throw (NoClassDefFoundError)new NoClassDefFoundError( 
        ex.toString() ).initCause( ex );
}

Map keys = new HashMap();
Map loaders = new HashMap();
 
 
public Object getKey(Object lookup)
{
  Object key;
 
  synchronized(keys) {
    key = keys.get(lookup);
    if (key == null) {
       key = lookup;
       keys.put(key, key);
    }
  }
 
  return key;
}
 
public Loader getLoader(Object lookup)
{
  Object key = getKey(lookup);
 
  synchronized(key) {
    WeakReference loaderRef;
 
    synchronized(loaders) {
      loaderRef = (WeakReference) loaders.get(key);
    }
 
    Loader loader;
 
    if (loaderRef == null || (loader = (Loader) loaderRef.get()) == null) {
        loader = createLoader(lookup);
        loaderRef = new WeakReference(loader);
 
        synchronized(loaders) { 
          loaders.put(key, loaderRef);
        }
    }
 
    return loader;
  }
}