Can garbage collector run on Static class objects

Question

I have to make class, who's object is never garbage collected . So If I give class as an static does it will avoid garbage collection on his objects,Or is ther any another way to do that ??

Answer 1

Short answer : No. Marking your class static may NOT save it from garbage collection

Making a class static may avoid garbage collection for the particular class loader which was responsible for loading it. However, if this classloader gets opted for garbage collection, then all classes loaded via it ( static or non-static ) will also be garbage collected.

Usually this is the case when you have multiple class loaders in your application.

Other than that, an object ( any object ) is opted for garbage collection when it becomes unreachable

From the JLS (source)

A class or interface may be unloaded if and only if its defining class loader may be reclaimed by the garbage collector [...] Classes and interfaces loaded by the bootstrap loader may not be unloaded.

Answer 2

Static variables are not reclaimed by the garbage collector when the corresponding static variable class is loaded into the JVM.

Please refer to below stackoverflow links

• Are static fields open for garbage collection?
• Class Loading in JVM
• Does the garbage collector work on static variables or methods in java?

Answer 3

An object is either reachable or unreachable, and this has nothing whatsoever to do with which class it is an instance of.

If your object is unreachable, it is garbage because you have no way to ever contact it.

If you want to make your object live on throughout the application's lifetime, simply assign it to a static variable so that it stays reachable forever. Basically, you are looking for the Singleton pattern.

The static modifier, applied to a class, is only allowed for nested classes and it makes that class a non-inner class, which means it does not need an enclosing instance. This has nothing to do with garbage collection concerns.

Answer 4

If I declare a class as an static, will that prevent garbage collection of its instances?

No.

The static modifier on a (nested) class means something rather different to static on a field. In particular, it has (almost¹) nothing to do with reachability or garbage collection.

Is there any another way to do this?

If you want to make sure that an instance of some class is never garbage collected, you must make sure that it is always reachable.

One approach is to declare a static variable and assign a reference to your instance to that variable. Under normal circumstances², the static variables remain reachable for an entire application run, and hence the objects that they reference remain reachable. That means they won't be garbage collected.

Another approach would be to hold the reference in a local variable declared in your main(...) method.

And there are other ways too.

---

^{1 - The slight gotcha is that an instance of a non-static nested class has an implicit reference to an instance of the enclosing class. But that affects the reachability of the latter instance, not the former instance.}

^{2 - There are circumstances in which a classes statics do get garbage collected, but involves creating classloaders and dynamic loading. In fact, a more common problem with this scenario is classes / instances that don't get garbage collected.}

Answer 5

If you want your class to not be garbage collected you have to keep it referenced. The best way to do it is to have your loader class (Application in Android for example) hold a reference to it. As long as Application is alive you can be sure that your class won't be touched by the garbage collector. Make sure it's a strong reference instead of a weak reference or even phantom reference