Reference Counting and Garbage Collection

15 min · Intermediate

Python frees memory for you, but you still decide how long objects stay alive. This lesson shows the rule behind it and the two cases, cycles and threads, that interviewers like to ask about.

Every object counts its references

A reference count is the number CPython stores in each object: how many names, containers or other objects refer to it. When the count drops to zero the object is destroyed immediately.

CPython keeps a counter inside every object: how many references point to it. Binding a name or adding it to a list adds one. Removing a reference subtracts one. At zero the memory is freed at once.

Python

1import sys2
3class Order:4    pass5
6order = Order()7before = sys.getrefcount(order)8backup = order9holder = [order]10print(sys.getrefcount(order) - before)11del backup, holder12print(sys.getrefcount(order) - before)

Example 1 · An object is freed the moment its last reference goes

Python

1class Ticket:2    def __init__(self, code):3        self.code = code4
5    def __del__(self):6        print("freed", self.code)7
8a = Ticket("T1")9b = a10del a11print("a deleted")12del b13print("b deleted")

Output

a deleted
freed T1
b deleted

What this code does

del a only removed one name, so the ticket stayed alive through b.
del b removed the last reference and __del__ ran at once.
This immediate release is a CPython detail. Other implementations may free later.

sys.getrefcount always reads one higher than you expect, because its own argument is a reference. Compare two readings, as here, instead of trusting one number.

What counts as a reference

A weak reference points to an object without raising its reference count. Calling it returns the object while it is alive and None after it has been freed.

Names, list items, dictionary values, attributes, function arguments and closures are all references. An object stays alive while any one of them remains. A weak reference watches an object without keeping it alive.

Python

1import weakref2
3class Report:4    pass5
6r = Report()7probe = weakref.ref(r)8print(probe() is r)9r = None10print(probe())

Example 2 · A container keeps its items alive

Python

1import weakref2
3class Session:4    pass5
6s = Session()7probe = weakref.ref(s)8active = [s]9del s10print(probe() is not None)11active.clear()12print(probe() is None)

Output

True
True

What this code does

After del s the list still refers to the session.
Clearing the list removes the last reference.
A forgotten list or cache is the usual cause of a memory leak in Python.

Rebinding r removed the only strong reference, so the object was freed and the weak reference now returns None. Note that del name removes a name, not the object.

Cycles and the garbage collector

The garbage collector is the part of Python that finds groups of objects referring only to each other and frees them. It runs on top of reference counting, which handles every other case.

Two objects that point to each other keep each other's count above zero, even when nothing else can reach them. The garbage collector in the gc module finds such cycles and frees them.

Python

1import gc, weakref2
3class Node:4    def __init__(self):5        self.other = None6
7gc.disable()8a, b = Node(), Node()9a.other, b.other = b, a10probe = weakref.ref(a)11del a, b12print(probe() is not None)13gc.collect()14print(probe() is None)15gc.enable()

Two nodes point to each other, so each keeps a reference count of one after the program drops its own names. Reference counting alone cannot free them; the garbage collector detects that nothing outside reaches them and frees both.

Example 3 · The collector reports what it freed

Python

1import gc2
3class Node:4    def __init__(self):5        self.other = None6
7gc.disable()8for _ in range(3):9    a, b = Node(), Node()10    a.other, b.other = b, a11del a, b12print("cycles found:", gc.collect() > 0)13print("generations:", len(gc.get_threshold()))14gc.enable()

Output

cycles found: True
generations: 3

What this code does

gc.collect() returns how many objects it freed. The exact number varies, so the example prints a comparison.
gc.get_threshold() holds one limit per generation.

Counting alone could not free the pair. gc.collect() found them unreachable. Normally the collector runs by itself, in three generations, so most programs never call it.

Threads and the GIL

The GIL, or global interpreter lock, lets only one thread run Python bytecode at a time in CPython. It protects the interpreter's own data, such as reference counts. It does not make your own multi-step code safe.

CPython has one global lock, the GIL. Only one thread runs Python bytecode at a time. This keeps the reference counts safe without a lock on every object.

Example 4 · The GIL does not make counter += 1 safe

Python

1import threading2
3counter = 04lock = threading.Lock()5
6def work():7    global counter8    for _ in range(1000):9        with lock:10            counter += 111
12threads = [threading.Thread(target=work) for _ in range(4)]13for t in threads:14    t.start()15for t in threads:16    t.join()17print(counter)

Output

What this code does

counter += 1 is several bytecode steps, and a thread switch can happen between them.
The lock makes the whole update one safe step.
Python 3.13 also offers an experimental build without the GIL, so locks matter even more there.

Next step

Check your understanding

11 quick questions

Every object counts its references

A reference count is the number CPython stores in each object: how many names, containers or other objects refer to it. When the count drops to zero the object is destroyed immediately.

CPython keeps a counter inside every object: how many references point to it. Binding a name or adding it to a list adds one. Removing a reference subtracts one. At zero the memory is freed at once.

1import sys2 3class Order:4 pass5 6order = Order()7before = sys.getrefcount(order)8backup = order9holder = [order]10print(sys.getrefcount(order) - before)11del backup, holder12print(sys.getrefcount(order) - before)

1class Ticket:2 def __init__(self, code):3 self.code = code4 5 def __del__(self):6 print("freed", self.code)7 8a = Ticket("T1")9b = a10del a11print("a deleted")12del b13print("b deleted")

What counts as a reference

A weak reference points to an object without raising its reference count. Calling it returns the object while it is alive and None after it has been freed.

Cycles and the garbage collector

The garbage collector is the part of Python that finds groups of objects referring only to each other and frees them. It runs on top of reference counting, which handles every other case.

Two objects that point to each other keep each other's count above zero, even when nothing else can reach them. The garbage collector in the gc module finds such cycles and frees them.

1import gc, weakref2 3class Node:4 def __init__(self):5 self.other = None6 7gc.disable()8a, b = Node(), Node()9a.other, b.other = b, a10probe = weakref.ref(a)11del a, b12print(probe() is not None)13gc.collect()14print(probe() is None)15gc.enable()

1import gc2 3class Node:4 def __init__(self):5 self.other = None6 7gc.disable()8for _ in range(3):9 a, b = Node(), Node()10 a.other, b.other = b, a11del a, b12print("cycles found:", gc.collect() > 0)13print("generations:", len(gc.get_threshold()))14gc.enable()

Threads and the GIL

CPython has one global lock, the GIL. Only one thread runs Python bytecode at a time. This keeps the reference counts safe without a lock on every object.

1import threading2 3counter = 04lock = threading.Lock()5 6def work():7 global counter8 for _ in range(1000):9 with lock:10 counter += 111 12threads = [threading.Thread(target=work) for _ in range(4)]13for t in threads:14 t.start()15for t in threads:16 t.join()17print(counter)