父子类双向引用是否会导致内存泄漏？是否应使用WeakReference？

Great question—this is such a common gotcha when working with object references, so it’s totally worth clarifying! Let’s break this down step by step:

1. 循环强引用会导致内存泄漏吗？ #

It depends entirely on the garbage collection (GC) mechanism your language uses:

• Modern reachability-based GC (e.g., Java HotSpot, .NET CLR, Python’s generational GC): No, this won’t cause a leak. These GCs track which objects are still reachable from "root" references (like static variables, active stack frames). If your parent and child objects only reference each other, and there’s no external reference pointing to either of them, the GC will recognize that neither is reachable from the root and will collect both. The circular reference doesn’t block collection here.
• Older reference-counting GC (e.g., some legacy systems, simple custom GC implementations): Yes, this can cause a leak. Reference-counting GCs track how many times an object is referenced; each object in the loop will have a reference count of at least 1 (from the other object), so they’ll never be marked for collection even if no external code uses them.

2. 什么时候需要用WeakReference？ #

You’ll want to use WeakReference when one of the references shouldn’t force the other object to stay alive. Let’s use a concrete example:
Suppose you have a Parent that manages temporary Child tasks. When a Child task is done, you want it to be eligible for GC even if the Parent is still alive. If the Parent holds a strong reference to the Child, the Child will stick around as long as the Parent does—even if no other code needs it.

Here’s how you’d adjust it with a weak reference (Java example):

import java.lang.ref.WeakReference;

class Parent {
    // Use WeakReference so the Child can be GC'd when no other strong references exist
    private WeakReference<Child> childRef;

    public void setChild(Child child) {
        this.childRef = new WeakReference<>(child);
        child.setParent(this);
    }
}

class Child {
    // If the Child doesn't need to keep the Parent alive, use WeakReference here too!
    private Parent parent;
}

Another scenario: If the Child is a listener attached to the Parent, you might want the Parent to be collectable even if the Child is still around. In that case, the Child should hold a WeakReference to the Parent instead of a strong one.

关键总结 #

• Circular strong references don’t leak memory with modern GCs—as long as the entire cycle is unreachable from external roots.
• Use WeakReference only when you need to break a strong dependency: When one object’s existence shouldn’t depend on the other staying alive.

内容的提问来源于stack exchange，提问作者TatiOverflow