Bỏ qua đến nội dung chính
Mục lục

Quản lý bộ nhớ Python: garbage collector, đếm tham chiếu

AIDev Team · duyệt: Nguyễn Việt Chung

Bài 16/17 · Chương 15

OOP nâng cao

  • 7 phút
  • Nâng cao
  • Python 3.14
  • Cập nhật

Quản lý bộ nhớ trong Python là việc Python tự cấp chỗ cho object khi bạn tạo nó và tự thu hồi chỗ đó khi không còn ai dùng tới. Cơ chế chính là đếm tham chiếu: mỗi object nhớ có bao nhiêu tên và chỗ chứa đang trỏ tới nó. Còn garbage collector (module gc) dọn những object trỏ vòng vào nhau, thứ mà phép đếm không tự dọn được.

Cần biết trước: is và ==, sao chép list, import và __init__ và self.

Đếm tham chiếu (reference counting) với sys.getrefcount()

Bài is và == cho thấy hai tên có thể cùng trỏ tới một list. Python đếm những chỗ trỏ như vậy, và hàm sys.getrefcount() cho bạn xem con số đó:

python
import sys

gio = ["trà đào", "bạc xỉu"]
print(sys.getrefcount(gio))
ban_sao = gio
don = {"ma": "DH1024", "mon": gio}
print(sys.getrefcount(gio))
del ban_sao
don["mon"] = []
print(sys.getrefcount(gio))

KẾT QUẢ

2
4
2

Chỉ có tên gio mà hàm in 2, vì lúc gọi, chính đối số của sys.getrefcount() cũng là một tham chiếu tạm. Thêm tên ban_sao và một chỗ trong dict don thì thành 4. Xóa tên và thay giá trị trong dict thì về lại 2. Một tham chiếu là bất kỳ chỗ nào giữ object: tên biến, phần tử list, giá trị dict, thuộc tính của object khác. Con số tuyệt đối có thể khác giữa các bản Python, nhất là bên trong hàm, nên hãy so hiệu trước và sau thay vì tin một con số. Đổi don["mon"] = [] thành don["mon"] = gio rồi chạy lại: dòng cuối in 3.

Khi nào object bị thu hồi: del và gán lại tên

Số tham chiếu về 0 là Python thu hồi object ngay. Để nhìn thấy lúc đó, ví dụ dưới dùng __del__, phương thức đặc biệt Python gọi ngay trước khi thu hồi object (chỉ để quan sát, code thật hiếm khi cần):

python
class DonHang:
    def __init__(self, ma):
        self.ma = ma
    def __del__(self):
        print("Thu hồi", self.ma)

a = DonHang("DH1024")
b = a
del a
print("Sau del a")
del b
print("Sau del b")
c = DonHang("DH1025")
c = DonHang("DH1026")
del c

KẾT QUẢ

Sau del a
Thu hồi DH1024
Sau del b
Thu hồi DH1025
Thu hồi DH1026

del a chỉ xóa tên a, object vẫn còn tên b nên chưa bị thu hồi. del b xóa tham chiếu cuối cùng, và __del__ chạy ngay trước dòng in kế tiếp. Gán lại c cho một đơn mới cũng bỏ một tham chiếu: đơn DH1025 hết người giữ nên bị thu hồi ngay tại dòng gán. Người giữ chìa khóa kho là hình ảnh dễ nhớ: kho chỉ khóa hẳn khi người cuối cùng trả chìa. Đổi b = a thành b = DonHang("DH2000") rồi chạy lại: dòng đầu in Thu hồi DH1024.

del xóa tên, nên tên đó cũng không dùng được nữa.

Garbage collector và tham chiếu vòng

Khi một object trỏ tới chính nó, hoặc hai object trỏ vào nhau, mỗi object luôn còn ít nhất một tham chiếu từ phía kia. Xóa hết tên bên ngoài, số đếm vẫn không về 0. Đó là tham chiếu vòng, và module gc có mặt để dọn chúng:

python
import gc

class DonHang:
    def __init__(self, ma):
        self.ma = ma
    def __del__(self):
        print("Thu hồi", self.ma)

don = DonHang("DH1024")
don.chinh_no = don
del don
print("Sau del, gc bật:", gc.isenabled())
gc.collect()
print("Sau gc.collect()")

KẾT QUẢ

Sau del, gc bật: True
Thu hồi DH1024
Sau gc.collect()

Sau del don, không tên nào trỏ tới đơn nữa, nhưng thuộc tính chinh_no vẫn giữ nó, nên __del__ chưa chạy. Garbage collector định kỳ dò các nhóm object chỉ còn trỏ vào nhau và thu hồi cả nhóm. gc.collect() bắt nó chạy ngay. Bình thường bạn không cần gọi: gc bật sẵn và tự chạy khi số object mới tạo vượt một ngưỡng, ngưỡng đó khác nhau giữa các bản Python. Đổi don.chinh_no = don thành don.chinh_no = None rồi chạy lại: dòng đầu in Thu hồi DH1024, vì không còn vòng nào.

Kiểm tra nhanh

  1. Ở cấp cao nhất của file, như ví dụ đầu bài, ngoài đối số tạm của lời gọi chỉ có đúng tên gio trỏ tới list. sys.getrefcount(gio) in số nào?

    • 1
    • 2
    • 0
  2. Trong ví dụ __del__, sau a = DonHang("DH1024"), b = a và del a, đơn DH1024 bị thu hồi lúc nào?

    • Ngay ở dòng del a
    • Ở dòng del b, khi tham chiếu cuối cùng mất
    • Chỉ khi gọi gc.collect()
  3. Những câu nào đúng về del và garbage collector?

    • Object trong tham chiếu vòng bị thu hồi ngay khi xóa tên cuối cùng bên ngoài
    • Module gc dọn những nhóm object chỉ còn trỏ vào nhau
    • gc.collect() bắt garbage collector chạy ngay
    • Sau b = a và del a, print(a.ma) vẫn in DH1024 vì object còn sống
  4. Đơn được thêm vào list cho_giao rồi del don. Dòng nào làm đơn bị thu hồi?

    • del don
    • Không dòng nào, đơn sống tới hết chương trình
    • cho_giao.clear(), khi list bỏ phần tử cuối cùng giữ đơn
Đúng hết lần đầu +15 XP

Bài tập

Đo số tham chiếu một đoạn code thêm vào

Viết them_tham_chieu(doi_tuong, ham): gọi ham() đúng một lần và cho biết nó làm số tham chiếu tới doi_tuong tăng thêm bao nhiêu. Đoạn code giữ object trong một list là thêm một tham chiếu, bỏ nó ra là bớt một. Hãy dùng sys.getrefcount() trước và sau lời gọi, vì con số tuyệt đối khác nhau giữa các bản Python.

Trả về: một int, âm khi ham() bớt tham chiếu.

python
import sys

def them_tham_chieu(doi_tuong, ham):
    pass  # Viết thân hàm thay cho dòng này

Tóm tắt

  • Python đếm tham chiếu tới mỗi object: tên biến, phần tử list, giá trị dict, thuộc tính đều tính.

  • sys.getrefcount(x) ở cấp cao nhất thường cho số đó cộng thêm 1 của chính đối số, còn trong hàm Python 3.14 có thể không cộng. Hãy so hiệu, đừng tin số tuyệt đối.

  • Số tham chiếu về 0 thì object bị thu hồi ngay, như khi del tên cuối hoặc gán tên cho object khác.

  • del ten xóa tên, không xóa object còn được chỗ khác giữ.

  • Tham chiếu vòng không bao giờ về 0; garbage collector của module gc dò và thu hồi chúng, gc.collect() bắt nó chạy ngay.

Câu hỏi thường gặp

Garbage collection trong Python có làm chương trình chậm không?

Thường không đáng kể. Phần lớn object được thu hồi nhờ đếm tham chiếu, một phép cộng trừ nhỏ mỗi lần gán. Garbage collector chỉ chạy định kỳ cho các vòng tham chiếu. Chương trình tạo rất nhiều object trong vòng lặp dài mới có thể thấy nó chạy, và lúc đó nên đo trước khi chỉnh.

Có nên gọi gc.collect() thường xuyên không?

Không cần. Python tự gọi garbage collector khi cần, và gọi tay chỉ tốn thời gian dò lại các object. gc.collect() hữu ích khi bạn muốn chắc chắn các vòng tham chiếu đã được dọn, như lúc kiểm tra bộ nhớ trong bài memory leak.

Cách Python quản lý bộ nhớ (memory management) khác C ở điểm nào?

Trong C, bạn tự xin bộ nhớ và tự trả, quên trả là rò rỉ, trả hai lần là lỗi nặng. Python làm cả hai việc thay bạn bằng đếm tham chiếu và garbage collector. Bạn chỉ cần lo không giữ tham chiếu lâu hơn cần thiết, như để object nằm mãi trong một list hay dict dùng chung.

Vì sao không nên dựa vào __del__ để dọn dẹp?

Vì thời điểm __del__ chạy phụ thuộc vào số tham chiếu và vào garbage collector, không cố định. Object trong vòng tham chiếu có thể chờ lâu, và khi chương trình kết thúc Python không hứa gọi __del__ cho mọi object. Đóng file hay kết nối thì dùng context manager với with, chạy đúng lúc khối lệnh kết thúc.

Chủ đề

garbage collector python

Bài này có hữu ích?

Hỏi đáp

Đang tải câu hỏi…

Tham vấn chuyên môn

Nguyễn Việt Chung

Nhà sáng lập AIDev và VietPlatform · Thạc sĩ AI MSE

  • Tốt nghiệp thủ khoa xuất sắc Thạc sĩ AI MSE.
  • Đồng sáng lập, CTO E-University, SVOnline: số hóa 10+ đại học, 40.000+ sinh viên.
  • Xây hệ thống AI cho doanh nghiệp tại VietPlatform.
Biên soạn: AIDev Team · Rà soát · Quy trình biên tập