Is it safe to use `functools.lru_cache` in FastAPI app?

In an example in the documentation, a functools.lru_cache is used for caching (in memory) an object that is shared across many requests, in order to avoid reading from disk once per user request.

The question is: in a more general setting where the cached function called has several arguments and the corresponding endpoint receives many concurrent requests, is it recommended to use functools.lru_cache as proposed within a FastAPI app even though it is not thread-safe?

from fastapi import FastAPI
import functools

app = FastAPI()

@functools.lru_cache
def make_slow_query(date: str) -> str:
    data = ...
    return data


@app.get("/data")
def get_data(date: str):
    return {
        "data": make_slow_query(date),
        ...
    }

---

Edit

Is it the usage of Depends what makes it “valid”? or could it be implemented without Depends (as above)?

from fastapi import FastAPI, Depends
import functools

app = FastAPI()

@functools.lru_cache
def make_slow_query(date: str) -> str:
    data = ...
    return data


@app.get("/data")
def get_data(queried_data: str = Depends(make_slow_query)):
    return {
        "data": queried_data,
        ...
    }

Thank you in advance.

[ycd]

Oh, FastAPI, by default, will not open any threads

This is not right, if your function is not a coroutine, FastAPI will run that request inside a threadpool.

If it’s all asyncio, is it safe to use non-thread-safe objects?

asyncio is not safe for direct usage of lru_cache, you may want to use something like aiocache for it.

Let’s assume we have a single worker process: when multiple requests are made to a FastAPI endpoint, is there a chance of multithreading happening, or is it all asyncio behind the scenes? (if this makes sense).

Yes it is possible, if your function is not a coroutine (async def), there is multi-threading happening, i explained quite deeply how it works in here -> https://github.com/tiangolo/fastapi/issues/2776#issuecomment-776659392

[coder3112]

It works locally for me too, but I was wondering if it would also work in a scenario of heavy workload. Thanks

If it works locally(testing with simple benchmarks), it SHOULD work in heavy workload as well.