Java – cross reference and garbage collection
There is an extensive object graph application The graph mainly consists of a set of subgraphs connected to the rest of the graph by a unique reference However, each such internal subgraph has some cross references between objects There was a time when such a subgraph needed to be discarded Can you only set enough to point unique references to this subgraph to qualify for garbage collection?
My concern is that internal cross references may "protect" the entire subgraph from garbage collection In other words, does the garbage collector understand enough to ensure that all references in the subgraph do not leave the boundary of the subgraph, so the whole subgraph can be cleared
Solution
As stated in this so question, circular references are well managed
Java does not do reference counting, it does "mark and scan" garbage collection If you follow all the activity references, find out what objects are "reachable" and clean up everything else
References that can be accessed by the object itself do not affect accessibility, so if they are empty, they are not important
The only case where setting a reference to null might make sense is to discard a very large object in the middle of a long - running method
In this case, setting null as the reference of the graph will help to form an isolated island (even an internal circular reference), as described in this article
You will find more details about inaccessible status in the truth about garbage collection:
cannot access
When no stronger reference exists, the object enters an unreachable state When an object is inaccessible, it is a candidate
Note the wording: just because an object is a collection candidate does not mean that it will be set immediately The JVM is free to defer collection until an object is needed immediately
It is important to note that not only powerful references will occupy an object in memory These must be references from the garbage collection root link GC root is a variable of a special class, including:
>Temporary variables on the stack (any thread) > static variables (from any class) > special references to JNI native code
Circular strong references do not necessarily lead to memory leaks Consider a code that creates two objects and assigns them to each other's references
public void buidDog() { Dog newDog = new Dog(); Tail newTail = new Tail(); newDog.tail = newTail; newTail.dog = newDog; }
Before the method returns, the temporary stack variable in the builddog method has a strong reference to "dog" and "tail"
After the builddog method returns, both dog and tail are inaccessible from the root directory and are candidates for collection (although the VM may not be able to collect these objects in real time for an indefinite period of time)