Скачать или смотреть Understanding WeakReference Behavior in Java: Why You Might See Non-Null Values

Explore the intricacies of `WeakReference` in Java, and understand why a weak reference might not return null even when you expect it to. Gain insights into garbage collection behavior and tips to effectively manage memory in your applications.
---
This video is based on the question https://stackoverflow.com/q/64371088/ asked by the user 'Jerem Lachkar' ( https://stackoverflow.com/u/4508962/ ) and on the answer https://stackoverflow.com/a/64371489/ provided by the user 'rzwitserloot' ( https://stackoverflow.com/u/768644/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Java / weak references : weak reference.get() is not null while there is no any more strong reference holding it

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Understanding WeakReference Behavior in Java: Why You Might See Non-Null Values

As a developer working with Java, you may encounter unexpected behaviors when using WeakReference objects, particularly around garbage collection (GC). A common issue arises when you expect to see null from a weak reference but find a non-null value instead. This can lead to confusion, especially when working with memory management in applications like Android. Let’s dive into the problem and explore how to effectively work with WeakReference and garbage collection.

The Problem at Hand

You’ve written a seemingly simple Java code snippet, involving a class that utilizes WeakReference. However, after clearing an array and calling the garbage collector, you see that the weak reference does not yield the null value you anticipated. This issue raises questions regarding the lifecycle of weak references and the nature of Java's garbage collection system.

Here’s a simplified version of your code that encapsulates the problem:

[[See Video to Reveal this Text or Code Snippet]]

Despite expectations, calling _o.get() does not return null. Let’s break down why this happens.

Understanding WeakReference and Garbage Collection

What is a WeakReference?

In Java, a WeakReference is a type of reference that does not prevent its referent from being made eligible for garbage collection. When the only references to an object are weak references, the garbage collector can reclaim the memory used by that object.

Key Points About WeakReference

Non-instantaneous Garbage Collection: The garbage collector runs non-deterministically. This means that just because you called System.gc() does not guarantee that the garbage collector will immediately collect the unreachable objects.

Merely a Hint: Both Runtime.getRuntime().gc() and System.gc() act as hints to the JVM that it might be a good time to run the garbage collector but do not guarantee it will happen immediately.

Debugger Effects: Sometimes, the debugger itself can keep references alive, causing the objects to appear non-collectable. When debugging, observing references may influence garbage collection, which might mislead your expectations.

Why Does _o.get() Return Non-null?

The reason your _o.get() might still return a non-null value, even after clearing the array and invoking garbage collection, includes:

Lifecycle of the Object: The object referenced by o is only eligible for garbage collection when there are no strong references left. In your test, _o remains a weak reference, but if o is still referenced as part of an object's lifecycle in your app, it may not be collected immediately.

Timing of Garbage Collection: The garbage collection process may not run right after you invoke it. You could see an effect of GC in subsequent lines of code if you introduce a Thread.sleep(), allowing time for the collector to process.

Effective Memory Management Strategies

Tips for Working with WeakReference

Understand Object Lifespan: Ensure you know the lifespan of your objects and how references work, particularly when they are stored in collections like ArrayList.

Validate Reference Clearances: After clearing collections or changing references, use a delay and recheck if the weak reference resolves to null afterwards.

Thread Sleep for Observation: If you're checking for the effect of garbage collection, consider implementing a delay after forcing GC, which may allow the collector to invoke and finalize necessary cleanup, improving your chances of seeing the expected results.

Monitor GC Activity: R