referencecounting

Reference counting is a form of memory management in which each object keeps a tally of how many references point to it. When a reference to an object is created, the count is incremented; when a reference is destroyed or reassigned, the count is decremented. If the count reaches zero, the object is deallocated.

Implementations typically maintain a per-object reference counter that is updated during pointer assignments and scope exits. In multi-threaded environments, increments and decrements may be performed atomically to prevent data races, or guarded by locks. Some runtimes optimize common paths with fast, thread-local counters, while others use shared atomic counters.

Reference counting is widely used through smart pointers and language runtimes. Examples include C++ shared_ptr, Rust Rc and Arc, Swift's Automatic Reference Counting, Objective-C, and Python's object system (which uses reference counting plus a cyclic garbage collector for cycles).

Advantages include deterministic destruction and low pause times, making it suitable for real-time or resource-constrained environments where timely reclamation is important. Drawbacks include the overhead of maintaining counts on every assignment, potential contention in multi-threaded contexts, and the inability to reclaim objects involved in reference cycles without additional mechanisms.

Cycles pose a major challenge: two or more objects referencing each other can keep counts above zero. Typical solutions involve weak references to break cycles, manual cycle collection strategies, or a supplementary cycle detector running periodically.

Reference counting contrasts with tracing garbage collection, which identifies unreachable objects via program-wide reachability analysis. In practice, reference counting is combined with other techniques to balance determinism and throughput.