How python manages memory

Python introduces a mechanism: reference counting to manage memory.

Python uses reference counting internally to keep track of objects in memory. Python internally records how many references an object has, that is, a reference count. When an object is created, a reference count is created. When the object is no longer When needed, this object's reference count reaches 0 and it is garbage collected.

To summarize, the reference count of an object will be increased by 1 in the following situations:

1. The object is created: x=4

2. Others Others are created: y=x

3. Passed as parameters to the function: foo(x)

4. As an element of the container object: a=[1,x,'33' ]

Reference count reduction situation

1. A local reference leaves its scope. For example, when the foo(x) function above ends, the object reference pointed to by x is decremented by 1.

2. The alias of the object is explicitly destroyed: del x; or del y

3. An alias of the object is assigned to another object: x=789

4. The object is removed from a window object: myList.remove(x)

5. The window object itself is destroyed: del myList, or the window object itself leaves the scope.

Garbage Collection

1. When there are parts of the memory that are no longer used, the garbage collector will clean them up. It checks for objects with a reference count of 0 and clears their space in memory. Of course, in addition to the reference count of 0 being cleared, there is another situation that will also be cleared by the garbage collector: when two objects refer to each other, their other references are already 0.

2. The garbage collection mechanism also has a circular garbage collector to ensure that the circular reference object is released (a refers to b, and b refers to a, causing its reference count to never be 0).

In Python, many times the memory applied for is small blocks of memory. These small blocks of memory will be released soon after application. Since these memory applications are not for creating objects, they are not There is no object-level memory pool mechanism. This means that Python will perform a large number of malloc and free operations during operation, and frequently switch between user mode and core mode, which will seriously affect the execution efficiency of Python. In order to speed up the execution efficiency of Python, Python introduces a memory pool mechanism to manage the application and release of small blocks of memory.

Memory pool mechanism

Python provides a garbage collection mechanism for memory, but it puts unused memory into the memory pool instead of returning it to the operating system.

All objects smaller than 256 bytes in Python use the allocator implemented by pymalloc, while large objects use the system's malloc. In addition, Python objects, such as integers, floating point numbers and Lists, have their own independent private memory pools, and their memory pools are not shared between objects. This means that if you allocate and free a large number of integers, the memory used to cache these integers can no longer be allocated to floating point numbers.

The above is the detailed content of How python manages memory. For more information, please follow other related articles on the PHP Chinese website!