java垃圾收集器 - “获取”已删除的对象

Question

是否有可能看到哪些对象将被垃圾收集器删除？ 我不需要对象的内容，但是对象的类是必要的。

我尝试编写一个实时应用程序，它创建并删除了很多对象，一段时间后应用程序运行速度变慢。 目前我不确定这是我的代码还是外部库的问题。 如此完美将是一个输出，它标识所有已被删除的类，以及它们的“计数”（已删除了多少这些对象）。

我希望有人可以帮助我。

最好，迈克尔

Answer 1

您可以尝试使用VisualVM监视您的应用程序。 有一个插件提供有关垃圾收集器活动的信息。

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

Answer 2

如何覆盖对象的finalize方法并在那里记录类的名称？ 请注意，这可能会阻止对象被垃圾回收。

你的课可能看起来像这样：

public class MyObject {

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

这是Object.finalize()方法签名和文档。

/**
 * 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

不是垃圾收集的对象会不会更有趣？

Anway，像VisualVM这样的内存分析器是你真正需要的。 它可以准确显示应用程序中每个类的对象数量，还可以通过比较GC之前和之后的堆转储来识别垃圾收集类和对象县。

Answer 4

我建议你使用任何java profilers，如JProfiler，Yourkit等。很容易看到垃圾收集的对象数量以及对象的类型。

Answer 5

垃圾收集的线程以低优先级运行。 所以这个线程没有轮到做清理任务了。

此外，不保证垃圾收集线程将始终运行。 在您的应用程序中，垃圾收集的低优先级线程无法通过应用程序线程执行。 因此堆不会从未使用的对象中清除，因此应用程序因堆大小有限而变慢。

您可以通过重写public void finalize()方法来计算垃圾回收的对象数。 检查javadoc以获取更多详细信息

我建议你使用一些java分析器来诊断内存问题。