Что произойдет, если не закрыть файл после чтения?

Что произойдёт, если не закрыть файл после чтения

Это классическая ошибка, которая приводит к утечке ресурсов и медленной деградации системы. Расскажу подробно о последствиях и как избежать этой ошибки.

1. Основной механизм утечки

Файл — это ресурс ОС (file descriptor), не просто объект Python

# ❌ ПЛОХО: файл не закрыт
def read_config():
    f = open("config.json")
    data = json.load(f)
    return data  # Забыли f.close()!

# ✅ ХОРОШО: файл закрыт
def read_config():
    f = open("config.json")
    try:
        data = json.load(f)
    finally:
        f.close()  # Гарантировано закроется

# ✅ ЛУЧШЕ: context manager
def read_config():
    with open("config.json") as f:
        data = json.load(f)
    # Автоматически закрывается после блока

Почему это критично:

import os
import resource

# Посмотреть лимит файловых дескрипторов
limit = resource.getrlimit(resource.RLIMIT_NOFILE)
print(f"Максимум открытых файлов: {limit[0]}")
# Обычно: 1024 (по умолчанию на Linux)

# Посмотреть сколько открыто сейчас
open_files = len(os.listdir("/proc/self/fd"))
print(f"Открытых файлов сейчас: {open_files}")

2. Практическое демонстрация утечки

import sys
import gc
import os

def leak_demo():
    """
    Демонстрация утечки файловых дескрипторов
    """
    print(f"Начальное количество открытых файлов: {len(os.listdir('/proc/self/fd'))}")
    
    # ❌ БЕЗ закрытия файлов
    for i in range(1100):
        f = open("test.txt")
        data = f.read()  # Прочитали
        # f.close() забыли!
    
    # Очистить мусор (может помочь)
    gc.collect()
    
    print(f"После цикла БЕЗ close: {len(os.listdir('/proc/self/fd'))}")
    # Output: ~1100 открытых файлов!
    
    # Если попытаться открыть ещё:
    try:
        f = open("another.txt")
    except OSError as e:
        print(f"Ошибка: {e}")
        # OSError: [Errno 24] Too many open files

leak_demo()

3. Последствия утечки файлов

1. Невозможно открыть новые файлы

try:
    with open("/var/log/app.log", "a") as f:
        f.write("Error occurred\n")
except OSError as e:
    print(f"Cannot write to log: {e}")
    # OSError: [Errno 24] Too many open files
    # Критично для логирования!

2. Команды ОС падают

# В shell, если процесс исчерпал дескрипторы:
$ ps aux  # Может не запуститься
$ ls      # Может не запуститься
$ find .  # Может не запуститься

# Потому что ОС не может открыть pipe для процессов

3. Веб приложение перестаёт обрабатывать запросы

from fastapi import FastAPI
import aiofiles

app = FastAPI()

@app.get("/upload-config")
async def upload_config():
    # При каждом запросе открываем файл
    f = open("config.json")
    config = f.read()
    # Забыли закрыть!
    
    return {"status": "ok"}

# После ~1000 запросов:
# OSError: [Errno 24] Too many open files
# API падает

4. Блокировка файлов

# Иногда файл остаётся заблокирован
f = open("database.db", "r")
data = f.read()
# Не закрыли

# Попытка скопировать или переместить файл:
# Windows: [Error 5] Access is denied
# Linux: может быть несогласованное состояние

4. Как это обнаружить

Вариант 1: Проверить lsof

# Посмотреть все открытые файлы процессом
lsof -p <PID>

# Или просто для процесса Python
lsof -p $$ | wc -l  # Количество открытых дескрипторов

# Если цифра растёт с каждым запросом — утечка!

Вариант 2: Программно отслеживать

import os
import psutil
from collections import deque

class FileDescriptorMonitor:
    def __init__(self, threshold=100):
        self.threshold = threshold
        self.history = deque(maxlen=100)
    
    def check(self):
        process = psutil.Process(os.getpid())
        fds = process.num_fds()
        self.history.append(fds)
        
        # Проверить тренд
        if len(self.history) > 10:
            recent = list(self.history)[-10:]
            if all(recent[i] < recent[i+1] for i in range(len(recent)-1)):
                # Постоянный рост
                print(f"WARNING: File descriptor leak detected! {fds} open")
        
        if fds > self.threshold:
            print(f"CRITICAL: Too many open files: {fds}")

monitor = FileDescriptorMonitor()

# Вызывать периодически
@app.middleware("http")
async def monitor_middleware(request, call_next):
    response = await call_next(request)
    monitor.check()  # Проверить после каждого запроса
    return response

5. Правильные паттерны

Паттерн 1: Context manager (рекомендуется)

# ✅ ПРАВИЛЬНО
with open("config.json") as f:
    config = json.load(f)
# Автоматически закрывается, даже при исключении

# Несколько файлов
with open("file1.txt") as f1, open("file2.txt") as f2:
    data1 = f1.read()
    data2 = f2.read()

Паттерн 2: Явное закрытие

f = open("data.json")
try:
    data = json.load(f)
    process(data)
finally:
    f.close()  # ВСЕГДА выполнится

Паттерн 3: Для асинхронного кода

import aiofiles

# ✅ Асинхронный context manager
async def read_config():
    async with aiofiles.open("config.json") as f:
        content = await f.read()
        return json.loads(content)
    # Автоматически закроется

# ✅ Без async with (если нужно)
async def read_config_manual():
    f = await aiofiles.open("config.json")
    try:
        content = await f.read()
    finally:
        await f.close()  # Важно: await!

Паттерн 4: С pathlib (современно)

from pathlib import Path
import json

# ✅ Самый современный способ
config = json.loads(Path("config.json").read_text())

# Для больших файлов:
with Path("data.json").open() as f:
    data = json.load(f)

6. Общие ошибки

Ошибка 1: Забыть close() в исключениях

# ❌ ПЛОХО
try:
    f = open("file.txt")
    data = json.load(f)
except json.JSONDecodeError:
    # f.close() не вызовется при исключении!
    raise

# ✅ ХОРОШО
try:
    with open("file.txt") as f:
        data = json.load(f)
except json.JSONDecodeError:
    # Файл всё равно закроется
    raise

Ошибка 2: Забыть в цикле

# ❌ ПЛОХО
for filename in filenames:
    f = open(filename)
    data = f.read()
    process(data)
    # f.close() забыли!
    # После 1000 файлов — crash

# ✅ ХОРОШО
for filename in filenames:
    with open(filename) as f:
        data = f.read()
        process(data)
    # Закроется на каждой итерации

Ошибка 3: В функции, вызываемой много раз

# ❌ ПЛОХО (веб приложение)
@app.get("/config")
def get_config():
    f = open("config.json")
    config = json.load(f)
    # f.close() забыли!
    return config

# После 1000 запросов — OSError

# ✅ ХОРОШО
@app.get("/config")
def get_config():
    with open("config.json") as f:
        config = json.load(f)
    return config

7. Реальный пример утечки и исправления

# БЕЗ исправления (утечка)
class DataProcessor:
    def __init__(self, data_dir):
        self.data_dir = data_dir
    
    def process_all_files(self):
        result = []
        for filename in os.listdir(self.data_dir):
            f = open(os.path.join(self.data_dir, filename))
            data = json.load(f)
            result.append(data)
            # f.close() забыли!
        return result

# С исправлением
class DataProcessor:
    def __init__(self, data_dir):
        self.data_dir = data_dir
    
    def process_all_files(self):
        result = []
        for filename in os.listdir(self.data_dir):
            filepath = os.path.join(self.data_dir, filename)
            # ✅ Context manager
            with open(filepath) as f:
                data = json.load(f)
                result.append(data)
        return result
    
    # Альтернативно
    def process_all_files_pathlib(self):
        from pathlib import Path
        result = []
        for filepath in Path(self.data_dir).glob("*.json"):
            # ✅ pathlib + read_text
            data = json.loads(filepath.read_text())
            result.append(data)
        return result

8. Мониторинг в production

import logging
import psutil
from functools import wraps

logger = logging.getLogger(__name__)

def monitor_file_descriptors(func):
    """Декоратор для мониторинга утечек файлов"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        process = psutil.Process()
        before = process.num_fds()
        
        try:
            result = func(*args, **kwargs)
        finally:
            after = process.num_fds()
            
            if after > before:
                logger.warning(
                    f"{func.__name__} leaked {after - before} file descriptors. "
                    f"Before: {before}, After: {after}"
                )
        
        return result
    return wrapper

@monitor_file_descriptors
def process_file(filename):
    with open(filename) as f:
        return f.read()

Краткий чек-лист

# Перед развёртыванием в production проверить:

# 1. Все open() используют with?
import ast
import sys

class OpenCallChecker(ast.NodeVisitor):
    def __init__(self):
        self.issues = []
    
    def visit_Call(self, node):
        if isinstance(node.func, ast.Name) and node.func.id == "open":
            # Проверить, внутри ли with?
            # (упрощённая проверка)
            print(f"Found open() at line {node.lineno}")

# 2. Нет ли утечек в тестах?
# pytest автоматически проверяет

# 3. Мониторинг в production?
# Следить за лимитом файловых дескрипторов

Итоговая таблица

┌──────────────────┬────────────┬──────────────────┐
│   Способ         │   Опасный  │  Когда использ.  │
├──────────────────┼────────────┼──────────────────┤
│ with (context)   │ ✅ Безопасен│ Всегда          │
│ try/finally      │ ✅ Безопасен│ Если нужна логика│
│ f.close()        │ ⚠️  Рискован│ Редко нужно      │
│ Без close()      │ ❌ Опасен   │ НИКОГДА!         │
│ pathlib.read_*   │ ✅ Безопасен│ Маленькие файлы  │
└──────────────────┴────────────┴──────────────────┘

Вывод

Если не закрыть файл:

1. Исчерпается лимит файловых дескрипторов ОС
2. Приложение не сможет открыть новые файлы → ошибки
3. Логирование сломается → потеря информации о проблемах
4. API упадёт → недоступность сервиса
5. Блокировка файлов → невозможно скопировать/удалить

Решение: Всегда использовать with open(...) или pathlib. Это один из самых важных паттернов в Python, который экономит дни debugging'а в будущем.