What is Garbage Collection in Python?

Introduction

In Python, garbage collection, or GC, is an automatic memory management function that optimizes resource usage by releasing memory that has been taken by objects that are no longer in use. Python finds and removes unnecessary objects using reference counting and a cyclic garbage collector. Memory is liberated when the number of references to an object is zeroed out, a process known as reference counting. On the other hand, the cyclic garbage collector finds and breaks reference cycles for objects that are a part of them, freeing up memory. By dynamically controlling memory allocation and deallocation, GC improves efficiency and frees up developers to concentrate on application logic rather than memory management.

Automatic Garbage Collection Of Cycles

Using Python's Generational Garbage Collection, items are sorted into three age groups: young, middle-aged, and old. Since most artifacts are transient, the younger generation is the source of new objects that are regularly collected. Objects that make it through several collections are elevated to older generations, which are less likely to be collected. By concentrating on recently produced items and minimizing the burden of frequent full heap searches, this method maximizes efficiency. The generational model makes use of the empirical finding that the majority of items pass away quickly, effectively managing memory by giving the most temporary objects the highest priority for cleanup.

Example

import gc

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

node1 = Node(1)
node2 = Node(2)

node1.next = node2
node2.next = node1

gc.collect()

print(gc.get_referrers(node1))
print(gc.get_referrers(node2))

Output:

References to node1: []
References to node2: []

After garbage collection, gc.get_referrers(node1) returns an empty list [], indicating that there are no more references to node1.

Similar to this, gc.get_referrers(node2) displays an empty list [], signifying that, following garbage collection, there are no more references to node2.

Explanation

Using a cyclic reference, the code generates two Node objects (node1.next points to node2 and vice versa). The garbage collector (gc.collect()) is specifically called to recover memory once the objects are created. There are no references to nodes 1 or 2 left after garbage collection, as indicated by the empty lists returned by gc.get_referrers(node1) and gc.get_referrers(node2). This ensures that the cyclic reference was successfully located and broken by Python's cyclic garbage collector, enabling effective memory cleanup of the relevant objects.

Manual Garbage Collection

In Python and other programming languages, the term "Automatic Garbage Collection of Cycles" describes how the system automatically maintains memory by identifying and freeing up memory that is used by cyclic references. When two or more objects indirectly or directly reference one another, it creates a cyclic reference, or cycle, that will not go away with simple reference counting. In order to ensure effective memory usage, Python uses a cyclic garbage collector, which periodically examines memory to find and break such cycles. In this procedure, objects are sorted into generations according to how long they have been around, with younger objects being collected more frequently. Python's garbage collection system helps minimize memory leaks and optimizes memory consumption by automating cycle detection and cleanup. This frees developers to concentrate on application logic instead of tedious memory management tasks.

Example

import gc

class Car:
    def __init__(self, brand):
        self.brand = brand
    
    def __del__(self):
        print(f"Deleting {self.brand} car")

car1 = Car("Toyota")
car2 = Car("Honda")

car1.other_car = car2
car2.other_car = car1

del car1
del car2

gc.collect()

print("End of program")

Output:

End of program
Deleting Honda car
Deleting Toyota car

Explanation

The Python application demonstrates cyclic reference object destruction and automatic garbage collection. It defines a class called Car, the instances of which have a __del__() function that prints a deletion notice and a brand attribute. A cyclic reference is used to generate and link the two Car objects, car1 (Toyota) and car2 (Honda) (car1.other_car = car2 and vice versa). Python's garbage collector recognizes and breaks the cyclic reference after eliminating direct references (del car1, del car2) and starting gc.collect() from the code. The "Deleting Honda car" and "Deleting Toyota car" messages are printed when this process calls the __del__() function for each vehicle object. "End of program" is printed at the end of the program to show how effectively Python can manage memory with automatic garbage collection.

Forced Garbage Collection

Programming terms for forced garbage collection describe the explicit calling of the garbage collector to recover memory that has been taken up by unneeded things right away. This can be accomplished in languages such as Python by utilizing the gc.collect() function found in the gc module. While forced garbage collection might be helpful in situations where instantaneous memory cleanup is required, such as before a memory-intensive operation to free up space or in real-time systems where predictable memory management is critical, automatic garbage collection operates on a periodic basis. By giving developers command over memory deallocation timing, it improves effectiveness and performance. However, because forced memory clearing requires more processing and may result in performance degradation, frequent use should be avoided.

Example

import gc

class LargeObject:
    def __init__(self):
        self.data = [0] * 1000000  

large_object = LargeObject()

del large_object

collected = gc.collect()

print(f"Unreachable objects collected: {collected}")

print("End of program")

Output:

Unreachable objects collected: 0
End of program

Explanation

A huge object instance (LargeObject) with high memory utilization is created in the provided Python script to illustrate forced garbage collection. Gatto collect() is used to start garbage collection right away when the reference to this object (del large_object) is deleted. Upon reference counting cleaning up the object, the number of unreachable objects gathered is reported, which is typically 0. At last, the script outputs "End of program," demonstrating the explicit memory management and resource reclamation that can be achieved in Python with forced garbage collection. In especially prior to memory-intensive processes, this guarantees effective memory utilization.

Disabling Garbage Collection

Python's automatic memory management system can be disabled to provide developers manual control over when and how memory is released. This is known as disabling garbage collection. When handling resources manually in a controlled environment or in performance-critical applications where trash collection overhead needs to be avoided, this can be helpful. The gc module is available in Python and contains functions such as gc.enable() to enable garbage collection again and gc.disable() to turn it off. While there are situations when turning off garbage collection can increase speed, doing so necessitates careful management to avoid memory leaks and make sure objects are dealt with appropriately because the automatic identification and cleanup of unwanted objects is no longer in place.

Example

import gc

class MyClass:
    def __init__(self, name):
        self.name = name
    
    def __del__(self):
        print(f"Deleting {self.name}")

gc.disable()

obj1 = MyClass("Object 1")
obj2 = MyClass("Object 2")

del obj1
del obj2

gc.enable()

gc.collect()

print("End of program")

Output:

End of program

Explanation

In the provided Python example, garbage collection is explicitly disabled using gc.disable(), preventing Python from automatically reclaiming memory from objects even after their references are deleted (del obj1, del obj2). This disables the invocation of the __del__() destructor method immediately upon object deletion. As a result, despite creating instances of MyClass (obj1 and obj2) and deleting their references, the program concludes with only the message "End of program" printed. Enabling garbage collection with gc.enable() restores automatic memory management, allowing Python to reclaim memory from unused objects in subsequent operations. This approach provides developers with manual control over memory management, useful for scenarios requiring precise resource handling or performance optimization in Python applications.

Advantages

1. Automatic Memory Management

The Python garbage collector automatically deletes objects that are no longer referenced in order to prevent memory leaks and reduce the likelihood of running out of memory.

Python is a higher-level and more useful language for developers since it eliminates the need for developers to manually manage memory, allowing them to focus on writing code. This is achieved through the garbage collector.

2. Effective Memory Cleanup

Generational garbage collection is a feature of the garbage collector that minimizes performance impacts while quickly recognizing and gathering things with a limited lifespan.

3. Configurable Settings

Developers can fine-tune the trash collection process according to their particular application requirements by using the garbage collector's customizable settings feature, which includes the ability to change the thresholds for different generations.

Disadvantages

1. Performance Impact

Even if the garbage collector is made to effectively remove unnecessary memory, there can still be some CPU usage and execution time overhead, especially when handling a lot of objects.

2. The Challenge Of Managing Memory

Python's garbage collector simplifies memory management, although understanding ideas like object lifetimes, object references, and garbage collection algorithms may still be necessary to use it effectively.

3. Restricted Command Over Memory Management

It may not be ideal for many application scenarios where fine-grained control over memory management is required because of the garbage collector's autonomous nature, which gives developers minimal control over the exact timing and behavior of memory cleanup.

Next Topic3d data processing with open3d

← prev next →