Why are reachable Java objects finalized in Java 8, despite best practices discouraging `finalize()`?

JVM Finalization of Reachable Objects in Java 8: An Exploration

Despite adhering to best practices that discourage the use of finalize(), a recent upgrade from Java 7 to Java 8 has brought to light an unexpected issue. In this scenario, objects that are still strongly reachable by the current thread's stack are being subjected to finalization in the Java 8 runtime.

Understanding the Code and Exception

The code in question involves a custom MIME library, where the MIMEBodyPart class extends HTTPMessage. HTTPMessage implements a finalize() method that attempts to close its associated input stream, leading to an exception when the stream is already closed during an active writePart() operation.

Investigating the Cause

Puzzled by the unexpected finalization, the developers delved deeper into the code and JVM behavior. It was discovered that the MIMEBodyPart object was indeed reachable from the current thread's stack, and therefore, shouldn't have been finalized.

Hypothesizing the Possibility of Unreachability

Despite the object's apparent reachability, it was theorized that the Java Virtual Machine (JVM) could still perceive it as unreachable if it is not explicitly referenced in subsequent code. This concept of "unreach ability" even extends to active method calls on the stack.

Example Demonstrating Unreachability

To illustrate this behavior, a simplified code example was presented:

class FinalizeThis {
    @Override
    protected void finalize() {
        System.out.println("finalized!");
    }

    void loop() {
        System.out.println("loop() called");
        for (int i = 0; i < 1,000,000,000; i++) {
            if (i % 1,000,000 == 0)
                System.gc();
        }
        System.out.println("loop() returns");
    }

    public static void main(String[] args) {
        new FinalizeThis().loop();
    }
}

In this example, the loop() method includes a massive loop that triggers garbage collection periodically. Despite the loop method actively calling an instance method of the FinalizeThis object, the JVM finalizes and garbage collects the object due to its apparent unreachability.

Applying the Hypothesis to the Original Scenario

It was conjectured that a similar situation could be unfolding in the case of the MIMEBodyPart object. If it was stored in a local variable without any subsequent references, it could become unreachable and susceptible to finalization.

Updates and Additional Observations

Through further testing and analysis, it became evident that the JIT compiler played a role in this behavior. By forcing methods to be JIT-compiled before execution (-Xcomp option), the issue of premature finalization re-emerged. This suggests that the initial lack of finalization in the simplified example was due to interpretation rather than compilation, which performs more aggressive reachability analysis.

Conclusion

While the specifics of the issue may vary depending on the exact code structure and execution environment, the underlying concept of potential finalization even for reachable objects due to perceived unreachability is noteworthy. It underscores the importance of understanding object reachability and the potential consequences of finalization calls on active objects.

The above is the detailed content of Why are reachable Java objects finalized in Java 8, despite best practices discouraging `finalize()`?. For more information, please follow other related articles on the PHP Chinese website!