BackgroundTasks blocks entire FastAPI application

[mostopalove]

First Check

• I added a very descriptive title here.
• I used the GitHub search to find a similar question and didn't find it.
• I searched the FastAPI documentation, with the integrated search.
• I already searched in Google "How to X in FastAPI" and didn't find any information.
• I already read and followed all the tutorial in the docs and didn't find an answer.
• I already checked if it is not related to FastAPI but to Pydantic.
• I already checked if it is not related to FastAPI but to Swagger UI.
• I already checked if it is not related to FastAPI but to ReDoc.

Commit to Help

• I commit to help with one of those options 👆

Example Code

from time import sleep
from fastapi import FastAPI, BackgroundTasks

app = FastAPI()


async def testing():
    print('I am going to block whole application')
    sleep(60)
    print('I am alive again after 60 seconds of blocking')


@app.get("/check")
def check():
    return 'It works'


@app.get("/task")
def add_task(background_tasks: BackgroundTasks):
    background_tasks.add_task(testing)
    return 'Task was added'

Description

To reproduce:

1. Request route /task
2. Request route /check

Expected result: /check route returns text result
Current result: request stuck in pending status, whole application doesn't response. Application returns results only when background task finishes

I saw similar question in discussion section in github but this bug doesn't related to any middleware. As you see I don't use middleware in code.
In my real product example I am using more complicated function so I can't make it synchronous (without async def)

Could you tell me how to use async code in the background in a FastAPI application please?

Operating System

macOS

Operating System Details

Mac OS Sonoma 14.3.1 (23D60)

FastAPI Version

0.110.0

Pydantic Version

2.6.2

Python Version

3.10.10

Additional Context

No response

[H-G-11]

Your issue is linked to the way Python handles asynchronous code, not FastAPI itself.

For instance, this works as expected:

from asyncio import sleep
from fastapi import FastAPI, BackgroundTasks

app = FastAPI()


async def testing():
    print('I am going to block whole application')
    await sleep(60)
    print('I am alive again after 60 seconds of blocking')


@app.get("/check")
def check():
    return 'It works'


@app.get("/task")
def add_task(background_tasks: BackgroundTasks):
    background_tasks.add_task(testing)
    return 'Task was added'

As you can see, the only difference is that now, your async background task is really asynchronous (asyncio.sleep and not time.sleep), it will not block the async loop.

Each Python thread has a single Asyncio event loop attached to it. This loop will continuously run through the different tasks, but the loop will block if there is a CPU intensive task coming up.

There are multiple solutions:

• make your async function really asynchronous (no CPU-intensive thing - as above)
• or make it synchronous (def ...)
• ... or put you async task in another thread - like the following

import asyncio
import threading

from time import sleep
from fastapi import FastAPI, BackgroundTasks

app = FastAPI()


def run_in_thread(target_function):
    """Decorator to run a function in a separate thread."""

    def run(*k, **kw):
        t = threading.Thread(target=target_function, args=k, kwargs=kw)
        t.start()
        return t

    return run

@run_in_thread
def testing_wrapper():
    asyncio.run(testing())


async def testing():
    print('I am going to block whole application')
    sleep(60)
    print('I am alive again after 60 seconds of blocking')


@app.get("/check")
def check():
    return 'It works'


@app.get("/task")
def add_task(background_tasks: BackgroundTasks):
    background_tasks.add_task(testing_wrapper)
    return 'Task was added'

[mostopalove]

You are write! Thank you very much!
I used sleep function as an example. My problem was that I wrap heavy synchronous calculation with async function, so as a result my entire app was waiting for it. I guess

[mastizada]

You can use from starlette.concurrency import run_in_threadpool for such blocking operations inside the task.

[JavierSanchezCastro]

That's because you are using a blocking call (sleep) in an async function. I suppose the sleep would be the repr. of your code. So I can understand you are using a block function or maybe without the "await" in your async background task.