Java garbage collector - “get” deleted objects

Question

Is it possible to see which objects will be deleted with the garbage collector? I don't need the content of the object, but the class of the object is needed.

I am trying to write a real-time application that creates and deletes many objects, and after a while the application slows down. At the moment, I'm not sure if this is a problem with my code or external libraries. So perfect is the output that identifies all the classes that have been deleted, together with their "count" (how many of these objects have been deleted).

I hope someone can help me.

Best Michael

Answer 1

You can try tracking your application using VisualVM. There is a plugin that gives information about the activity of the garbage collector.

http://visualvm.java.net/plugins.html

Answer 2

How about overriding the finalize method for your objects and registering the class name there? Beware, however, this may interfere with garbage collection.

Your class might look something like this:

 public class MyObject { @Override public void finalize() throws Throwable { logger.debug("Object of class {} being garbage collected", this.getClass().getName()); } } 

Here is the signature and documentation of the Object.finalize() method.

 /** * Called by the garbage collector on an object when garbage collection * determines that there are no more references to the object. * A subclass overrides the <code>finalize</code> method to dispose of * system resources or to perform other cleanup. * <p> * The general contract of <tt>finalize</tt> is that it is invoked * if and when the Java<font size="-2"><sup>TM</sup></font> virtual * machine has determined that there is no longer any * means by which this object can be accessed by any thread that has * not yet died, except as a result of an action taken by the * finalization of some other object or class which is ready to be * finalized. The <tt>finalize</tt> method may take any action, including * making this object available again to other threads; the usual purpose * of <tt>finalize</tt>, however, is to perform cleanup actions before * the object is irrevocably discarded. For example, the finalize method * for an object that represents an input/output connection might perform * explicit I/O transactions to break the connection before the object is * permanently discarded. * <p> * The <tt>finalize</tt> method of class <tt>Object</tt> performs no * special action; it simply returns normally. Subclasses of * <tt>Object</tt> may override this definition. * <p> * The Java programming language does not guarantee which thread will * invoke the <tt>finalize</tt> method for any given object. It is * guaranteed, however, that the thread that invokes finalize will not * be holding any user-visible synchronization locks when finalize is * invoked. If an uncaught exception is thrown by the finalize method, * the exception is ignored and finalization of that object terminates. * <p> * After the <tt>finalize</tt> method has been invoked for an object, no * further action is taken until the Java virtual machine has again * determined that there is no longer any means by which this object can * be accessed by any thread that has not yet died, including possible * actions by other objects or classes which are ready to be finalized, * at which point the object may be discarded. * <p> * The <tt>finalize</tt> method is never invoked more than once by a Java * virtual machine for any given object. * <p> * Any exception thrown by the <code>finalize</code> method causes * the finalization of this object to be halted, but is otherwise * ignored. * * @throws Throwable the <code>Exception</code> raised by this method */ protected void finalize() throws Throwable { } 

Answer 3

Will objects that are not collected with garbage be still interesting?

Anway, a memory profiler such as VisualVM , is what you really need. It can show you how many objects of each class exist in your application, and it can also display garbage collected classes and county objects by comparing heap heaps before and after GC.

Answer 4

I would recommend using any of the java profiles like JProfiler, Yourkit etc. It is very easy to see the amount of garbage collected objects, as well as the type of object.

Answer 5

The garbage collection thread runs with low priority. Therefore, this thread does not perform its task to perform the cleanup task.

It is also not guaranteed that the garbage collection stream will always work. Here in your application, a low priority garbage collection thread does not get the ability to execute on application threads. Thus, the heap is not cleared of unused objects, and therefore, the application slows down due to the limited heap size.

You can count the amount of garbage collected by overriding the public void finalize() method. Learn more about javadoc

I would recommend that you use some java profilers to diagnose a memory problem.