Why Reference Counting Fails: Understanding GC, Memory Leaks, and Circular References

Why Garbage Collection Matters

Out‑of‑memory (OOM) errors and GC pauses degrade performance and user experience. Automatic memory management (garbage collection, GC) helps avoid these problems.

Manual Memory Management Example (C)

// Step 0: char* aMem;
// Step 1:
aMem = (char*)malloc(sizeof(char) * 1024);
// Step 2:
strcpy(aMem, "I am a bunch of memory");
// Step 3:
free(aMem);

Typical pitfalls of this pattern:

Memory leak : Re‑assigning aMem without freeing the original block loses the first allocation.

Allocation failure : If the system cannot provide 1024 bytes, malloc returns NULL and the program must handle the error.

Buffer overflow : Copying a string larger than the allocated space corrupts memory.

Invalid free : Calling free on a NULL pointer or on an already freed block crashes the program.

Stale pointer : After free, the pointer still holds the old address, which is dangerous if reused.

The Need for Automatic Memory Management

Manual management is error‑prone. Languages with automatic memory management let the runtime identify and reclaim unreachable objects, reducing code size and improving correctness.

Developers no longer need to reason about exact lifetimes of every allocation.

Common leaks and invalid frees are eliminated, making applications more robust.

GC Algorithm Families

Reference Counting : Each object stores a counter of how many references point to it.

Object Tracing (Mark‑Sweep, Generational, etc.) : The collector walks reachable objects from roots and reclaims everything else.

Reference Counting Basics

Each object stores a reference count.

When an object is created, its count starts at 1.

Every new reference increments the count.

When a reference is overwritten or goes out of scope, the count is decremented.

When the count reaches 0, the object is reclaimed.

Java‑like illustration:

public class A {
    private void method() {
        System.out.println("I am a method");
    }
    public static void main(String[] args) {
        A a1 = new A(); // a1.rc++
        A a2 = new A(); // a2.rc++
        a2 = a1; // a2's original object rc-- (possibly 0 → reclaimed); a1.rc++
    }
}

Circular‑Reference Problem

Objects that reference each other keep each other's counters above zero, preventing reclamation even when the cycle is unreachable from program roots.

class Parent { Child child; }
class Child { Parent parent; }
public class Main {
    public static void main(String[] args) {
        Parent p = new Parent();
        Child c = new Child();
        p.child = c;
        c.parent = p; // cycle: both objects have rc = 1
    }
}

Breaking Cycles

Programmer‑assisted : Use weak references (e.g., weak in Swift, std::weak_ptr in C++) that do not increment the count, allowing cycles to be broken manually.

Runtime‑assisted : The collector runs a separate detection phase (often combined with tracing GC) to find and collect cyclic groups.

Pros and Cons of Reference Counting

Advantages : Simple design, immediate reclamation when count reaches 0, no stop‑the‑world phase.

Disadvantages : Every pointer update incurs a ++/-- operation, affecting performance; cyclic references require extra handling; runtime‑assisted cycle detection adds algorithmic complexity and may introduce pause times.

Reference Counting Example (Java)

public class A {
    private void method() {
        System.out.println("I am a method");
    }
    public static void main(String[] args) {
        // Assume each object has a field rc (reference count)
        A a1 = new A(); // a1.rc++
        A a2 = new A(); // a2.rc++
        a2 = a1; // a2's original object rc--, possibly 0 → reclaimed; a1.rc++
        // Function exit: a1 and a2 go out of scope, their rc--
        // If rc reaches 0, the objects are reclaimed.
    }
}

Further Reading

Upcoming articles will cover tracing‑based GC algorithms (Mark‑Sweep, Generational, etc.) used by V8, Android ART, Java HotSpot, OpenJ9, and Go.

Technical reference: https://github.com/Tencent/TencentKona-8