Garbage Collection Mechanism in Python

In Python, Garbage Collection (GC) is an automatic memory management process responsible for reclaiming memory occupied by objects that are no longer in use. Python primarily employs two mechanisms: Reference Counting and Generational GC.

1. Reference Counting

   • Basic Concept: Each object has a counter that records how many references point to it. When the reference count drops to 0, the object is immediately reclaimed.
   • Counting Rules:
     • The count is 1 when an object is created (e.g., a = [1, 2]).
     • The count increases by 1 when a reference is added (e.g., b = a).
     • The count decreases by 1 when a reference is removed (e.g., del a or when a variable goes out of scope).
   • Advantages: Immediate reclamation, no delay.
   • Disadvantages: Cannot handle circular references (e.g., two objects referencing each other), leading to memory leaks.

2. Generational GC

   • Addressing Circular References: Since reference counting cannot handle circular references, Python introduces Generational GC as a supplement.
   • Generational Principle:
     • Objects are divided into 3 generations (generation 0, 1, and 2). Newly created objects belong to generation 0.
     • Each generation has an independent threshold (viewable via gc.get_threshold()). When the number of objects exceeds the threshold, garbage collection for that generation is triggered.
     • Collection process: Starting from root objects (e.g., global variables, variables on the stack), living objects are marked, and unmarked objects are reclaimed. Surviving objects are moved to the next generation.
   • Advantages: Effectively handles circular references and reduces the frequency of global scans.

3. Triggering Garbage Collection

   • When the reference count drops to 0 (immediate reclamation).
   • When the generational GC threshold is triggered (automatic execution).
   • Manually calling gc.collect() to force collection.

4. Example Illustrating Circular References

   class Node:
       def __init__(self):
           self.parent = None
           self.children = []
   
   # Creating a circular reference
   a = Node()
   b = Node()
   a.children.append(b)  # a references b
   b.parent = a          # b references a
   # After deleting the variables, the reference count is not 0 (due to circular references) and requires generational GC to handle.
   del a, b
   

5. Practical Recommendations

   • Avoid manual garbage collection management unless dealing with a large number of temporary objects.
   • Circular references commonly occur in custom classes and containers (e.g., lists, dictionaries), so design with care.
   • Use the gc module (e.g., gc.disable()) for debugging or performance optimization.

Through the combination of reference counting and generational GC, Python achieves efficient memory management, freeing developers from explicitly releasing memory.