Когда может пригодиться модуль gc в Python?

Модуль gc (Garbage Collector) в Python

Модуль gc используется для управления автоматическим сборщиком мусора (garbage collector). Python имеет встроенный GC на основе подсчета ссылок (reference counting), но также использует cycle detector для обнаружения циклических ссылок.

Когда пригождается gc

1. Отключение GC для повышения производительности в критичных местах

import gc

# Отключить GC перед интенсивными вычислениями
gc.disable()

try:
    # Критичный код где нельзя задержек на сборку мусора
    process_large_data()
finally:
    # Включить обратно и собрать мусор
    gc.enable()
    gc.collect()  # Явная сборка

print(f"Собрано объектов: {gc.collect()}")  # Возвращает количество

2. Отладка утечек памяти

import gc

class CircularReference:
    def __init__(self):
        self.ref = self  # Циклическая ссылка

# Создание множество объектов
objs = [CircularReference() for _ in range(1000)]

# Найти объекты до сборки мусора
gc.collect()
print(f"Количество объектов до: {len(gc.get_objects())}")

# Удалить все ссылки
del objs

# После сборки
gc.collect()
print(f"Количество объектов после: {len(gc.get_objects())}")

# Получить объекты которые не могут быть собраны
print(f"Мусор: {gc.garbage}")

3. Получение информации о сборщике мусора

import gc

# Узнать поколения
gc.enable()
print(f"Поколения: {gc.get_count()}")  # (count0, count1, count2)

# Статистика
print(f"Всего объектов: {len(gc.get_objects())}")

# Объекты для определенного типа
strings = [obj for obj in gc.get_objects() if isinstance(obj, str)]
print(f"Строк: {len(strings)}")

# Получить статистику сборок
stats = gc.get_stats()
for generation in stats:
    print(f"Поколение {generation['generation']}: {generation}")

4. Обнаружение циклических ссылок

import gc

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

# Создать циклическую ссылку (которую не ловит reference counting)
node1 = Node(1)
node2 = Node(2)
node1.next = node2
node2.next = node1  # Цикл!

# Без gc.collect() эти объекты были бы в памяти
del node1, node2

print(f"До collect: {len(gc.garbage)}")
if gc.is_tracked(node1):  # Проверить отслеживается ли
    print("Объект отслеживается GC")

freed = gc.collect()  # Собрать мусор
print(f"Собрано {freed} объектов")

5. Контроль поколений (Generational GC)

import gc

# Поколение 0: молодые объекты, часто сканируются
# Поколение 1: средневозрастные, реже сканируются
# Поколение 2: старые объекты, еще реже

# Пороги: сборка поколения когда количество объектов >= порога
thresholds = gc.get_threshold()
print(f"Пороги: {thresholds}")  # Обычно (700, 10, 10)

# Установить свои пороги (реже сборки = быстрее, но больше памяти)
gc.set_threshold(1000, 15, 15)

# Собрать конкретное поколение
gc.collect(generation=0)  # Собрать только молодые объекты

6. Управление отладкой

import gc

# Включить отладку для отслеживания сборки
gc.set_debug(gc.DEBUG_STATS)

# Выполнить код
data = [1] * 1000000

# Отключить отладку и собрать
gc.collect()

# Вывести статистику
print(gc.get_stats())

# Отключить отладку
gc.set_debug(0)

Реальные примеры использования

Пример 1: Оптимизация приложения с интенсивными вычислениями

import gc
import time

def process_with_gc():
    start = time.time()
    data = [i for i in range(10000000)]
    result = sum(data)
    print(f"С GC: {time.time() - start:.3f}s")

def process_without_gc():
    gc.disable()
    start = time.time()
    data = [i for i in range(10000000)]
    result = sum(data)
    print(f"Без GC: {time.time() - start:.3f}s")
    gc.collect()  # Собрать в конце
    gc.enable()

process_with_gc()
process_without_gc()

Пример 2: Flask приложение с контролем памяти

from flask import Flask
import gc

app = Flask(__name__)

@app.before_request
def before_request():
    # Отключить GC для обработки запроса
    gc.disable()

@app.after_request
def after_request(response):
    # Включить и собрать после обработки
    gc.enable()
    gc.collect()
    return response

@app.route('/')
def index():
    return "Hello World"

Пример 3: Отладка утечки памяти в долгоживущем процессе

import gc
import tracemalloc

tracemalloc.start()

def leaky_function():
    # Функция которая утекает память
    return [1] * 1000000

# Собрать несколько раз
for i in range(5):
    leaky_function()  # Результат не сохраняется
    gc.collect()
    current, peak = tracemalloc.get_traced_memory()
    print(f"Итерация {i}: {current / 10**6:.1f} MB")

# Вывести топ памяти
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:3]:
    print(stat)

Когда нужен gc.collect()

Используй когда:

• Нужно гарантировать освобождение памяти в конкретный момент
• Отладка утечек памяти
• После удаления больших объектов
• В критичных по памяти местах (сервер, контейнер)

НЕ используй когда:

• Хочешь микрооптимизировать (GC обычно эффективнее)
• Это становится работой вместо правильного дизайна

Поколения в Python

import gc

# Зачем нужны поколения?
# Молодые объекты часто умирают, старые живут долго
# Поэтому сканируем молодое поколение чаще

gc.enable()  # Включить GC
print(gc.is_enabled())  # True
print(gc.get_count())  # (0, 0, 0) - счетчики для каждого поколения

Итог: Используй gc для отладки утечек памяти, оптимизации критичных участков кода и управления памятью в долгоживущих процессах. Но помни: большинство времени встроенный GC Python работает эффективнее, чем ручное управление.