Python quản lý bộ nhớ và thu gom rác (garbage collection) như thế nào?

Question

Accepted Answer

Python quản lý bộ nhớ **tự động** dùng hai cơ chế: **đếm tham chiếu (reference counting)** (phương pháp chính) cộng với một **bộ thu gom rác chu trình (cyclic garbage collector)** xử lý các chu trình tham chiếu. Bạn không bao giờ giải phóng bộ nhớ thủ công, nhưng hiểu cách nó hoạt động giải thích hành vi bộ nhớ và rò rỉ.

## Đếm tham chiếu — cơ chế chính

```python
import sys

x = [1, 2, 3]        # đối tượng list có refcount 1
y = x                 # refcount 2 (một tên khác tham chiếu nó)
sys.getrefcount(x)    # hiển thị số đếm (cao hơn một chút do chính lời gọi)

del y                 # refcount 1
del x                 # refcount 0 → đối tượng được GIẢI PHÓNG ngay lập tức
```

Mỗi đối tượng theo dõi có bao nhiêu tham chiếu trỏ tới nó. Khi số đếm giảm về **không**, bộ nhớ được giải phóng **ngay lập tức**. Điều này có tính tất định và kịp thời — các đối tượng chết ngay khi không còn gì tham chiếu chúng.

## Vấn đề: các chu trình tham chiếu

```python
# chỉ đếm tham chiếu không thể giải phóng cái này:
a = {}
b = {}
a["b"] = b      # a tham chiếu b
b["a"] = a      # b tham chiếu a → chúng tham chiếu LẪN NHAU
del a, b        # các tên đã biến mất, nhưng các đối tượng vẫn tham chiếu lẫn nhau
# → refcount không bao giờ về 0 → chúng sẽ rò rỉ nếu chỉ có đếm tham chiếu
```

Hai đối tượng tham chiếu lẫn nhau giữ refcount của nhau trên không ngay cả khi không thể tiếp cận được — một chu trình mà đếm tham chiếu thuần túy không thể thu gom.

## Bộ thu gom rác chu trình

```python
import gc

# bộ GC theo thế hệ định kỳ tìm và giải phóng các CHU TRÌNH không thể tiếp cận
gc.collect()        # kích hoạt thu gom thủ công
gc.get_count()      # các đối tượng được theo dõi theo từng thế hệ
```

Bộ **thu gom rác theo thế hệ (generational)** bổ sung của Python định kỳ phát hiện và giải phóng các chu trình không thể tiếp cận này. Nó *theo thế hệ* — các đối tượng mới hơn được kiểm tra thường xuyên hơn (hầu hết đối tượng chết khi còn trẻ), điều này hiệu quả.

## Hệ quả thực tế và nguồn rò rỉ

```text
✓ Hầu hết bộ nhớ được thu hồi kịp thời qua đếm tham chiếu
⚠️ Rò rỉ vẫn xảy ra từ các tham chiếu CÓ THỂ TIẾP CẬN tồn tại lâu hơn mức hữu dụng:
   - các cache/list toàn cục chỉ tăng lên
   - các đối tượng được giữ bởi closure hoặc thuộc tính class tồn tại lâu
   - các callback/listener đã đăng ký không bao giờ được gỡ bỏ
```

GC xử lý các chu trình, nhưng nó không thể giải phóng các đối tượng vẫn *có thể tiếp cận* — "rò rỉ" phổ biến trong thực tế là việc vô tình giữ các tham chiếu sống (ví dụ một cache toàn cục ngày càng lớn).

## Các chi tiết khác

```text
- Các số nguyên nhỏ (-5..256) và chuỗi ngắn được CACHE/intern (chia sẻ, tái sử dụng)
- CPython dùng các memory pool (pymalloc) cho các đối tượng nhỏ (hiệu quả)
```

## Tại sao điều này quan trọng

Hiểu mô hình bộ nhớ của Python — đếm tham chiếu kịp thời cộng với một GC chu trình — giải thích các hành vi thực tế: tại sao đối tượng thường được giải phóng ngay lập tức, tại sao các chu trình tham chiếu cần GC, và quan trọng là tại sao "rò rỉ bộ nhớ" trong Python đến từ các tham chiếu *có thể tiếp cận* (cache ngày càng lớn, closure tồn đọng, callback chưa gỡ bỏ) thay vì việc quên giải phóng.

Kiến thức này thiết yếu để chẩn đoán tăng trưởng bộ nhớ trong các dịch vụ chạy lâu và để viết code có ý thức về bộ nhớ — biết rằng cách khắc phục thường là phá vỡ các tham chiếu (giới hạn cache, dọn dẹp các đăng ký) thay vì bất cứ điều gì GC có thể làm cho bạn.