When Are Static Fields in Java Garbage Collected?

Understanding Garbage Collection for Static Fields

In Java, static fields are those that are declared within a class but are not bound to a specific instance. They play a crucial role in various scenarios, such as maintaining shared data across instances and facilitating program configuration. However, a common question arises: when will static fields be garbage collected?

To address this, let's consider the example of the hypothetical utility class MyUtils:

class MyUtils {
   private static MyObject myObject = new MyObject();
   /*package*/static boolean doStuff(Params... params) {
       // do stuff with myObject and params...
   }
}

The question is, will the static field myObject be eligible for garbage collection once it is no longer in use?

The Rules of Garbage Collection

Understanding the rules of garbage collection is key to answering this question. Static variables, like other objects in the Java heap, are subject to the following general garbage collection rule: an object is eligible for garbage collection when it is no longer reachable by any live references.

Static Field Exception

However, an important exception exists for static fields. Even if they are no longer reachable by any references from active instances, static fields cannot be elected for garbage collection while the class they belong to is still loaded. This is because static fields are accessible at any time, regardless of whether a specific instance of the class is in use.

Class Loader Role

Therefore, the fate of a static field is tied to the class loader that loaded its class. If the class loader is reclaimed by the garbage collector, it will trigger the unloading of all classes loaded by that class loader, including the class that holds the static field. This, in turn, will finally make the static field eligible for garbage collection.

Class Unloading in Practice

Class unloading is a rare event in the Java Virtual Machine (JVM), but it can occur in specific situations. For example, it may happen when the application undergoes dynamic class loading and unloads unused classes to free up memory resources.

Conclusion

In summary, static fields cannot be garbage collected while the class they belong to is loaded. They can only be collected when the respective class loader is itself collected for garbage. This behavior ensures that static fields remain accessible as long as the class they are declared in is available.

The above is the detailed content of When Are Static Fields in Java Garbage Collected?. For more information, please follow other related articles on the PHP Chinese website!