Reference counting in Python garbage collection mechanism

The __del__ magic method in Python, also known as the object's terminator, is a method that is called just before the object is about to be removed from memory. It doesn't actually do the job of removing the object from memory, we'll see how that happens later. Instead, this method is used to do any cleanup that needs to occur before the object is removed. For example, close any files that were open when the object was created.

In this section, we will use the following class as an example.

class MyNameClass:
def __init__(self, name):
self.name = name

def __del__(self):
print(f"Deleting {self.name}!")

In the above example, we have defined our class to accept a name as input when initialized, and when the finaliser is called, it will let us know by printing the name of the relevant instance. This way, we can learn which objects were deleted from memory and when.

So, when does CPython decide to delete an object from memory? There are two ways (as of CPython 3.10) that this can happen: reference counting and garbage collection.

Reference Counting

If we have a pointer to an object in Python, it is a reference to the object. For a given object a , CPython keeps track of how many other things point to a . If this counter reaches zero, it is safe to remove the object from memory since nothing else is using it. Let's look at an example.

>>> Harward = MyNameClass("Harward")
>>> del Harward
Deleting Harward!
>>>

Here, we create a new object (MyNamedClass("Harward")) and create a pointer to it (Harward =). Then, when we delete Harwade, we delete this reference and the MyNamedClass instance now has a reference count of 0. So, CPython decides to delete it from memory - and, just before doing so, its __del__ method is called, printing the message we saw above.

If we create multiple references to an object, we will have to get rid of all references in order for the object to be deleted.

>>> bob = MyNameClass("Bob")
>>> bob_two = bob # creating a new pointer to the same object
>>> del bob # this doesn't cause the object to be removed...
>>> del bob_two # ... but this does
Deleting Bob!

Of course, our MyNamedClass instances can themselves contain pointers - they are arbitrary Python objects after all, and we can add any properties we like to them. Let's look at an example.

>>> jane = MyNamedClass("Jane")
>>> bob = MyNamedClass("Bob")
>>> jane.friend = bob # now the "Jane" object contains a pointer to the "Bob" object...
>>> bob.friend = jane

What we did in the above code snippet is set up some circular references. An object named Jane contains a pointer to an object named Bob, and vice versa. Things get interesting when we do the following.

>>> del jane
>>> del bob

We have now removed the pointer from the namespace to the object. Now, we have no access to those MyNameClass objects at all -- but we don't get a print message telling us that they are about to be deleted. This is because these objects still have references, contained within each other, so their reference counts are not 0 .

What we create here is a loop isolate; in this structure, each object has at least one reference in the loop, keeping it alive, but all objects in the loop cannot be removed from the namespace was visited.

Intuitive performance of loop isolation

The following is the intuitive performance when we create a loop isolation.

First, we create two objects, each object has a name in the namespace.

Next, we connect our two objects by adding a pointer to each object.

#Finally, we remove the pointers from the namespace by removing the original names of both objects. At this point, the two objects are not accessible from the namespace, but each object contains a pointer to the other object, so their reference counts are not zero.

So, it is obvious that reference counting alone is not enough to keep the runtime working memory free of useless, non-recyclable objects. This is where CPython's garbage collector comes into play.

The above is the detailed content of Reference counting in Python garbage collection mechanism. For more information, please follow other related articles on the PHP Chinese website!