Python Memory Management — Reference Counting, GC & the GIL

Python makes memory management so easy that most developers never have to think about it. But under the hood, CPython (the standard Python implementation) uses a complex system to allocate, track, and free memory.

Reference Counting: The First Line of Defense

Unlike JavaScript or Java, which rely purely on tracing garbage collectors, CPython's primary memory management tool is reference counting.

Every object in Python has a reference count — an integer tracking how many variables, lists, or other objects point to it:

When you create an object (a = [1, 2, 3]), its ref count is 1.

When you assign it to another variable (b = a), its ref count becomes 2.

When a variable goes out of scope or is reassigned, the ref count drops.

When the reference count hits zero, CPython immediately reclaims the memory. This is highly deterministic and efficient.

The Problem: Reference Cycles

Reference counting has one fatal flaw: reference cycles.

a = {}
b = {}
a['b'] = b
b['a'] = a
del a
del b

Even though a and b are no longer accessible from the program, they point to each other. Their reference counts will never reach zero. This is a memory leak.

The Cyclic Garbage Collector

To fix this, CPython has a secondary system: a tracing garbage collector that runs periodically to find and destroy reference cycles. It analyzes objects that can contain other objects (like lists, dicts, instances) and determines if they are part of an isolated cycle.

Memory Pools and Pymalloc

Requesting memory from the OS is slow. To speed things up, Python uses a system called pymalloc for small objects (under 512 bytes). It requests large blocks of memory (arenas) from the OS and divides them into smaller pools.

The Global Interpreter Lock (GIL)

Why does Python have the GIL? Because of memory management! Reference counting is not thread-safe. If two threads incremented an object's reference count at the exact same moment, the count could be corrupted.

The GIL prevents multiple native threads from executing Python bytecodes at once. It makes reference counting safe, but limits CPU-bound multi-threading.

Conclusion

Understanding reference counting, cyclic GC, and the GIL helps you write faster, leak-free Python programs. Test your Python code in our Python Playground to see memory allocation in action.