Приведи пример когда нужно обратиться к модулю gc

Когда нужен модуль gc (Garbage Collector)

Модуль gc в Python управляет сборкой мусора. Большинству разработчиков он не нужен, но есть специфические сценарии.

Как работает сборка мусора в Python?

Reference Counting: Python использует подсчёт ссылок (reference counting). Когда счётчик объекта = 0, он удаляется.

import sys

# Объект создан
x = []
print(sys.getrefcount(x))  # 2 (сама переменная + параметр функции)

# Ещё одна ссылка
y = x
print(sys.getrefcount(x))  # 3 (x, y + параметр)

# Удаляем ссылку
del y
print(sys.getrefcount(x))  # 2 снова

Circular References (циклические ссылки): Есть проблема: циклические ссылки не удаляются reference counting.

class Node:
    def __init__(self):
        self.ref = None

# Циклическая ссылка
a = Node()
b = Node()
a.ref = b
b.ref = a
# Теперь a указывает на b, b указывает на a
# У каждого счётчик = 1, но они оба мусор!
del a
del b
# Reference counting не удалит их, потому что они друг на друга ссылаются
# Вот тут нужен gc модуль!

Для этого нужен Generational Garbage Collector:

• Автоматически находит циклические ссылки
• Удаляет недостижимые объекты
• Работает в фоне по поколениям (generations)

Пример 1: Отключение gc для производительности (тяжёлые вычисления)

import gc
import time

# Тяжёлый алгоритм
def heavy_computation():
    result = []
    for i in range(1000000):
        result.append({"id": i, "value": i * 2})
    return sum(len(r) for r in result)

# Обычный запуск
start = time.time()
heavy_computation()
print(f"С gc: {time.time() - start:.3f}s")  # ~0.5s

# Отключить gc для этой операции
gc.disable()
start = time.time()
heavy_computation()
print(f"Без gc: {time.time() - start:.3f}s")  # ~0.3s (на 30% быстрее!)
gc.enable()

Почему это помогает?

• Сборка мусора требует времени CPU
• Если много временных объектов, gc часто запускается
• Отключив gc, даёшь алгоритму больше CPU времени
• После завершения gc.enable() очищает весь мусор

Пример 2: Отключение gc в микросервисе для low-latency

import gc
from fastapi import FastAPI

app = FastAPI()

# Отключить сборку мусора глобально
gc.disable()

@app.get("/fast-endpoint")
def fast_endpoint():
    # Обработка запроса без пауз от gc
    data = [i for i in range(10000)]
    return {"count": len(data)}

# Запускаем gc в фоне, а не во время обработки запросов
import threading

def periodic_gc():
    while True:
        time.sleep(10)  # Каждые 10 секунд
        gc.collect()
        print("GC collection completed")

gc_thread = threading.Thread(target=periodic_gc, daemon=True)
gc_thread.start()

Применение:

• High-frequency trading (нельзя пропускать тики)
• Real-time игры (нельзя фризы 50ms)
• Микросервисы с SLA < 10ms

Пример 3: Отладка утечек памяти

import gc

class DataCache:
    def __init__(self):
        self.cache = {}
    
    def add(self, key, value):
        self.cache[key] = value

# Утечка памяти — кэш растёт, но мы забыли его очищать
cache = DataCache()
for i in range(1000000):
    cache.add(f"key_{i}", [j for j in range(100)])

# Процесс сожрал все памяти, но как найти утечку?

# Способ 1: Использовать gc для отладки
print(gc.get_objects())  # Список ВСЕх объектов в памяти
# Слишком много! Ищем по типам:

from collections import Counter
types_count = Counter(type(obj).__name__ for obj in gc.get_objects())
print(types_count.most_common(10))
# [('list', 1000000), ('dict', 900000), ...]

# Способ 2: Отследить объекты до и после
gc.collect()  # Очистить мусор

before = set(id(obj) for obj in gc.get_objects())
cache.add("big_key", list(range(100000)))
gc.collect()

after = set(id(obj) for obj in gc.get_objects())
new_objects = after - before
print(f"Создано новых объектов: {len(new_objects)}")

Пример 4: Явный вызов gc.collect() для критичных мест

import gc

def batch_processing(items):
    results = []
    
    for i, item in enumerate(items):
        # Процесс каждого элемента
        result = process_heavy(item)
        results.append(result)
        
        # Каждые 100 элементов — явно очистить мусор
        if i % 100 == 0:
            gc.collect()
            print(f"Processed {i} items, cleaned garbage")
    
    return results

def process_heavy(item):
    # Создаём много временных объектов
    temp = [x * x for x in range(10000)]
    return len(temp)

Когда это нужно:

• Обработка больших файлов
• Batch-операции с миллионами элементов
• Периодическая очистка памяти в long-running сервисе

Пример 5: Отключение циклической сборки мусора

import gc

# По умолчанию gc работает в 3 поколениях (generation 0, 1, 2)
# Это автоматический process, но можно управлять вручную

# Отключить автоматическую сборку мусора
gc.disable()

# А сам контролировать её
for i in range(1000):
    # Много работы
    data = [j ** 2 for j in range(10000)]
    
    # Каждую итерацию самостоятельно выбираем поколение для сборки
    if i % 10 == 0:
        gc.collect(0)  # Только молодое поколение (быстро)
    elif i % 100 == 0:
        gc.collect(2)  # Полная сборка мусора (медленно)

gc.enable()

Пример 6: Получение статистики gc

import gc

# Включить отслеживание объектов
gc.set_debug(gc.DEBUG_SAVEALL)

# Создать циклическую ссылку
class A:
    pass

a = A()
b = A()
a.ref = b
b.ref = a

del a, b

# Выполнить сборку
gc.collect()

# Получить объекты, которые были собраны
garbage = gc.garbage
print(f"Собрано объектов: {len(garbage)}")

# Получить статистику по поколениям
gc.get_count()  # (объекты в gen0, gen1, gen2)
gc.get_stats()  # Детальная статистика

Пример 7: Проблема с del методом

import gc

# ПРОБЛЕМА: __del__ и циклические ссылки
class FileHandler:
    def __init__(self, filename):
        self.file = open(filename, 'w')
        self.backup = None
    
    def __del__(self):
        print(f"Closing file")
        self.file.close()

# Циклическая ссылка
handler1 = FileHandler("file1.txt")
handler2 = FileHandler("file2.txt")
handler1.backup = handler2
handler2.backup = handler1

del handler1
del handler2

# Файлы НЕ закроются! __del__ не вызовется из-за циклических ссылок
# gc.collect() поможет:

gc.collect()  # Теперь __del__ вызовется

Решение: использовать weakref вместо циклических ссылок:

import weakref

handler1.backup = weakref.ref(handler2)  # Слабая ссылка
handler2.backup = weakref.ref(handler1)  # Не циклическая!

del handler1
del handler2
# Теперь __del__ вызовется сразу

Когда НЕ нужен gc?

• Большинство web приложений — Flask, Django, FastAPI автоматически управляют памятью
• Обычные скрипты — gc работает отлично автоматически
• Если нет утечек памяти — просто не трогай

Когда нужен gc?

1. High-performance вычисления — отключить для скорости
2. Отладка утечек памяти — найти растущие объекты
3. Real-time системы — контролировать паузы сборки мусора
4. Long-running сервисы — периодическая очистка памяти
5. Циклические ссылки с del — принудительная очистка

Золотое правило: Не трогай gc, если не сломалось. Если сломалось — измеряй сначала, потом оптимизируй.