Unloading classes in java?

java

class-loading

garbage-collection

class-unloading

byAnton Shumikhin·Mar 9, 2025

Unload Java classes by nullifying references to a custom ClassLoader and its loaded classes, thus marking them for garbage collection:

class MyClassLoader extends ClassLoader { 
    // Time to take out the trash
}

MyClassLoader loader = new MyClassLoader();
Class<?> myClass = loader.loadClass("MyClass");

// Do some stuff with the class...

// Ready for the big sleep
myClass = null;
loader = null;

// Dropping hints to the GC
System.gc();

Key: Class unloading effectively happens via custom ClassLoader isolation. Note that System.gc() is a suggestion to the JVM, not a command.

Deep dive into class unloading

The relationship between class unloading and the garbage collector (GC) is akin to a dance coordinated around the lifecycle of the ClassLoader. When ClassLoader instances are garbage collected, any classes they loaded become eligible for GC, if no more references exist.

Harnessing the power of multiple classloaders

Consider employing multiple Classloaders for diverse portions of your application:

Individual JARs for each module of your app.
Assign each JAR a unique JarClassLoader.
MultiClassLoader manages different class versions per connection or peer.

OSGi: The heavyweight champion

For large-scale applications teeming with complex dependencies, it's worth looking into OSGi:

Efficient and powerful dependency management.
Robust component lifecycle control.
Enhanced updates and version management capabilities.

The art of classloader strategy

Deploy proxy Classloaders and invent custom class loading strategies to master the class lifecycle:

Determine class loading sequence to mitigate conflicts.
Keep class and classloader associations in HashMaps for ease of management.
Supervise classloader hierarchy to boost stability with a proxy classloader.

Design considerations

A correct hierarchy to keep ClassCastException and LinkageError at bay.
Delegate responsibility wisely to prevent system ClassLoader bottleneck.
Plan for quick class reloading, negating the need for JVM restarts.

The lifecycle of your not-so-average classloader

ClassLoader Lifecycle:
1. Birth (🌱)
2. Load'em up, partner! (📦🆙)
3. The end (of the world as we know it) (⌛) ==> Brings forth GC 🚚 unloading classes (♻️📤)

Forcing the hand of class unloading

Rare occasions call for forced class unloading without the gruesome task of killing off the JVM. This peculiar feat can be accomplished:

By playing 'dead': drop all references to the class and its faithful ClassLoader.
By nudging the garbage collector using System.gc(), albeit it's more of a polite hint than an imperious command.

Dancing to different class versions

In the wild world of server farms, the MultiClassLoader strategy comes to the rescue:

Juggling several versions of a single class in the air simultaneously, because who doesn't love a good challenge?
Dividing the load (and unload) cycles into separate baskets, based on server connections (one per MultiClassLoader).

It's not you, it's me: dropping references for GC

For a class to bow out gracefully, it's essential to:

Sever all static and instance bonds.
Ensure threads aren't running around executing methods of the class like headless chickens.
See to it proxies, caches, pools take a step back, accepting the end of class instances.

explain-codes / Java / Unloading classes in java?

Linked

What is a fat JAR?



How to include jar files with java file and compile in command prompt



What does OSGi solve?



How can I create an executable/runnable JAR with dependencies using Maven?



How to import a jar in Eclipse?

