Làm thế nào để gc thu thập python làm việc?

Tóm lược. trong hướng dẫn này, bạn sẽ tìm hiểu cách thức hoạt động của trình thu gom rác Python và cách tương tác với trình thu gom rác theo chương trình

Giới thiệu về bộ sưu tập rác Python

Trong C/C++, bạn hoàn toàn chịu trách nhiệm quản lý bộ nhớ của chương trình. Tuy nhiên, trong Python, bạn không phải tự quản lý bộ nhớ vì Python đã tự động làm việc đó cho bạn

Trong phần hướng dẫn về tài liệu tham khảo, bạn đã học được rằng Trình quản lý bộ nhớ Python theo dõi các tài liệu tham khảo của các đối tượng. Trình quản lý bộ nhớ hủy đối tượng và lấy lại bộ nhớ sau khi số lượng tham chiếu của đối tượng đó bằng 0

Tuy nhiên, việc đếm tham chiếu không phải lúc nào cũng hoạt động bình thường. Ví dụ: khi bạn có một đối tượng tham chiếu chính nó hoặc hai đối tượng tham chiếu lẫn nhau. Điều này tạo ra một thứ gọi là tham chiếu vòng tròn

Khi Trình quản lý bộ nhớ Python không thể xóa các đối tượng có tham chiếu vòng tròn, nó sẽ gây rò rỉ bộ nhớ

Đây là lý do tại sao trình thu gom rác ra đời để sửa các tham chiếu vòng tròn

Python cho phép bạn tương tác với trình thu gom rác thông qua mô-đun

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

5 tích hợp

Tương tác với trình thu gom rác Python

Trong ví dụ này, trước tiên chúng ta sẽ tạo một tham chiếu vòng giữa hai thể hiện của lớp A và lớp B. Sau đó, chúng tôi sử dụng trình thu gom rác để hủy các đối tượng trong tham chiếu vòng tròn

Đầu tiên, nhập mô-đun

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

5 và

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

7 và xác định hai chức năng để đếm tham chiếu và kiểm tra xem đối tượng có tồn tại trong bộ nhớ không

import gc
import ctypes


def ref_count[address]:
    return ctypes.c_long.from_address[address].value


def object_exists[object_id]:
    for object in gc.get_objects[]:
        if id[object] == object_id:
            return True

    return False
Code language: Python [python]

Trong mã này,

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

8 trả về số lượng tham chiếu của một đối tượng được chỉ định bởi địa chỉ bộ nhớ của nó. Và hàm

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

9 trả về

gc.disable[]
Code language: Python [python]

0 nếu một đối tượng tồn tại trong bộ nhớ

Thứ hai, tạo hai lớp

gc.disable[]
Code language: Python [python]

1 và

gc.disable[]
Code language: Python [python]

2 có tham chiếu lẫn nhau

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

Thứ ba, vô hiệu hóa bộ thu gom rác bằng cách gọi hàm

gc.disable[]
Code language: Python [python]

3

gc.disable[]

  

Code language: Python [python]

Thứ tư, tạo một thể hiện mới của lớp A cũng tự động tạo một thể hiện mới của B

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

2

đầu ra

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

3

Thứ năm, xác định hai biến để giữ địa chỉ bộ nhớ của các thể hiện của A và B. Các biến này theo dõi địa chỉ bộ nhớ của các thể hiện của A và B khi biến

gc.disable[]
Code language: Python [python]

4 tham chiếu đến một đối tượng khác

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

5

Thứ sáu, hiển thị số lượng tham chiếu của các phiên bản của A và B

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

6

Thể hiện của A có hai tham chiếu là biến

gc.disable[]
Code language: Python [python]

4 và thể hiện của B. Và thể hiện của B có một tham chiếu là thể hiện của A

Thứ bảy, kiểm tra xem cả hai trường hợp của A và B có trong bộ nhớ không

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

8

Cả hai đều tồn tại

Thứ tám, đặt một biến thành

gc.disable[]
Code language: Python [python]

6

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

0

Thứ chín, lấy số tham chiếu của thể hiện của A và B

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

1

Bây giờ, cả hai số tham chiếu của phiên bản A và B là 1

Thứ mười, kiểm tra xem các trường hợp tồn tại

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

8

Cả hai vẫn tồn tại như mong đợi

Thứ mười một, bắt đầu thu gom rác

class A:
    def __init__[self]:
        self.b = B[self]
        print[f'A: {hex[id[self]]}, B: {hex[id[self.b]]}']


class B:
    def __init__[self, a]:
        self.a = a
        print[f'B: {hex[id[self]]}, A: {hex[id[self.a]]}']
Code language: Python [python]

1

Khi trình thu gom rác chạy, nó có thể phát hiện tham chiếu vòng tròn, hủy các đối tượng và lấy lại bộ nhớ

GC thu thập hoạt động như thế nào?

GC thu thập trả về Python là gì?

Việc thu gom rác diễn ra như thế nào trong Python?

Tôi có nên gọi GC thu thập Python không?