Python_BE1

1 view23:36

🖥 Задача: "Кэширование и ленивые вычисления в многопоточном окружении"

🔜 Условие:

Вам нужно реализовать декоратор `@thread_safe_cached`, который:

- Кэширует результат вызова функции по её аргументам (аналог `functools.lru_cache`, но свой).
- Если несколько потоков одновременно вызывают функцию с одинаковыми аргументами:
- Только один поток реально выполняет функцию,
- Остальные ждут, пока результат будет вычислен, и получают готовый результат.
- Кэш никогда не удаляется (неограниченный размер).

Ограничения:

- Решение должно работать для произвольных функций и аргументов (hashable).
- Нельзя использовать готовый `functools.lru_cache` или другие библиотеки кэширования.
- Нужно обеспечить корректную работу в многопоточной среде без гонок данных.

---

▪️ Подсказки:

- Для кэширования подойдёт `dict` с ключами по аргументам (`*args`, `**kwargs`).
- Для защиты доступа к кэшу понадобится `threading.Lock`.
- Для ожидания завершения вычисления другими потоками можно использовать `threading.Event`.
- Продумайте carefully: как отличить "результат уже посчитан" от "результат в процессе вычисления".

---

▪️ Что оценивается:

- Умение работать с многопоточностью в Python.
- Правильная организация кэширования.
- Чистота и лаконичность кода.
- Умение обрабатывать тонкие случаи, например: одновременные вызовы.

---

▪️ Разбор возможного решения:

Основная идея:

- Создать кэш `cache: Dict[Key, Result]`.
- Одновременно создать словарь "ожиданий" `in_progress: Dict[Key, threading.Event]`.
- Если кто-то начал считать значение:
- Остальные ждут `Event`, пока оно не будет установлено.

Пример реализации:
```

import threading
import functools

def thread_safe_cached(func):
cache = {}
in_progress = {}
lock = threading.Lock()

.wraps(func)
def wrapper(*args, **kwargs):
key = (args, frozenset(kwargs.items()))
with lock:
if key in cache:
return cache[key]
if key not in in_progress:
in_progress[key] = threading.Event()
in_progress[key].clear()
creator = True
else:
creator = False

if creator:
try:
result = func(*args, **kwargs)
with lock:
cache[key] = result
finally:
in_progress[key].set()
with lock:
del in_progress[key]
return result
else:
in_progress[key].wait()
with lock:
return cache[key]

return wrapper

```

---

▪️ Пояснения к коду:

- При первом вызове для новых аргументов поток создаёт `Event` и начинает считать результат.
- Остальные потоки видят `Event` и вызывают `wait()`, пока первый поток не установит `set()`.
- Как только результат посчитан, `Event` сигнализирует всем ждущим потокам, что данные готовы.
- Доступ к `cache` и `in_progress` защищён через `lock` для избежания гонок.

---

▪️ Возможные подводные камни:

- ❗ Если не удалять `Event` из `in_progress`, кэш постепенно раздуется мусором.
- ❗ Если ошибка случится внутри `func`, необходимо всё равно освободить `Event`, иначе потоки будут вечно ждать.
- ❗ Нельзя держать `lock` во время выполнения тяжёлой функции `func`, иначе все потоки будут блокироваться.

---

▪️ Вопросы на собеседовании по этой задаче:

- Как изменить реализацию, чтобы кэш имел ограничение по размеру (например, максимум 1000 элементов)?
- Как адаптировать декоратор под асинхронные функции (`async def`)?
- Что будет, если `func` иногда бросает исключения? Как кэшировать ошибки или не кэшировать их?
- Как изменить реализацию так, чтобы кэш удалял устаревшие данные через TTL (Time-To-Live)?

---

@python_be1

2 views15:35