Calling tasks asynchronously in Flask - Step-by-Step Execution

Concept Flow - Calling tasks asynchronously

Start Flask app

↓

Receive HTTP request

↓

Trigger async task

↓

Return response immediately

↓

Async task runs in background

↓

Task completes and stores result

This flow shows how a Flask app triggers a background task asynchronously, returns a response immediately, and the task runs separately.

Execution Sample

Flask

from flask import Flask, request
from threading import Thread

app = Flask(__name__)

def background_task():
    print('Task running')

@app.route('/start-task')
def start_task():
    thread = Thread(target=background_task)
    thread.start()
    return 'Task started'

if __name__ == '__main__':
    app.run()

This code defines a Flask app with a route that starts a background task in a separate thread and returns a response immediately.

Execution Table

Step	Action	Evaluation	Result
1	Start Flask app	App ready to receive requests	App running
2	Receive HTTP request	Request received at /start-task	Trigger async task
3	Trigger async task	Start Thread(target=background_task)	Thread started, task runs in background
4	Return response	Return 'Task started' immediately	Client gets response quickly
5	Background task runs	Print 'Task running'	Message printed in console
6	Task completes	Thread finishes execution	Background task done

💡 After task completes, Flask app continues running and can handle more requests.

Variable Tracker

Variable	Start	After Step 3	After Step 5	Final
app	Flask instance created	Running	Running	Running
thread	None	Thread object created and started	Thread running	Thread finished
response	None	None	None	'Task started' sent to client

Key Moments - 2 Insights

Why does the client get a response immediately even though the task is still running?

Because the task runs in a separate thread (Step 3), Flask returns the response right away (Step 4) without waiting for the task to finish.

What happens if the background task takes a long time?

The client is not blocked and gets the response immediately. The task continues running in the background (Step 5) until it finishes (Step 6).

Visual Quiz - 3 Questions

Look at the execution table, what happens at Step 3?

A The Flask app stops running

B The client receives the final result

C A background thread is started to run the task

D The HTTP request is ignored

💡 Hint

Check Step 3 in the execution_table where the thread is started.

At which step does the client receive the response?

A Step 4

B Step 3

C Step 2

D Step 6

💡 Hint

Look for the step where 'Return response' happens in the execution_table.

If the background task prints a message, when does this happen?

A Before the response is sent

B After the response is sent

C At the same time as the response

D It never prints

💡 Hint

See Step 5 in the execution_table where the task prints the message.

Concept Snapshot

Calling tasks asynchronously in Flask:
- Use a separate thread or worker to run long tasks
- Trigger the task inside the request handler
- Return HTTP response immediately
- Background task runs without blocking the client
- Useful for sending emails, processing files, etc.

Full Transcript

This visual trace shows how a Flask app handles asynchronous tasks. When the app receives a request, it starts a background thread to run a task. The app immediately returns a response to the client without waiting. The background task runs separately and prints a message when running. This approach keeps the app responsive and avoids blocking users while tasks run.

Practice

1. What is the main benefit of calling tasks asynchronously in a Flask app?

easy

A. It forces users to refresh the page manually.

B. It makes the app run slower by adding extra steps.

C. It disables other parts of the app until the task finishes.

D. It allows the app to handle long tasks without making users wait.

Solution

1. Step 1: Understand asynchronous task purpose

   Asynchronous tasks let the app do long jobs in the background.

2. Step 2: Connect to user experience

   This means users don't have to wait for the task to finish before using the app.

3. Final Answer:

   It allows the app to handle long tasks without making users wait. -> Option D

4. Quick Check:

   Async tasks improve user wait time = C [OK]

Hint: Async tasks run in background, so users don't wait [OK]

Common Mistakes:

• Thinking async tasks slow down the app
• Believing users must refresh manually
• Assuming async disables other app parts

2. Which of the following is the correct way to start a background thread in Flask?

easy

A. start_thread(task)

B. thread.start(task())

C. threading.Thread(target=task).start()

D. Thread.run(task)

Solution

1. Step 1: Recall Python threading syntax

   To start a thread, create Thread with target function, then call start().

2. Step 2: Match options to syntax

   threading.Thread(target=task).start() matches correct syntax: threading.Thread(target=task).start()

3. Final Answer:

   threading.Thread(target=task).start() -> Option C

4. Quick Check:

   Correct thread start syntax = A [OK]

Hint: Use threading.Thread(target=func).start() to run async [OK]

Common Mistakes:

• Calling start() on the function instead of the thread
• Using undefined functions like start_thread
• Confusing run() with start() method

3. Given this Flask code snippet, what will be printed?

from threading import Thread
from flask import Flask
app = Flask(__name__)
def background_task():
    print('Task done')
@app.route('/')
def index():
    Thread(target=background_task).start()
    return 'Hello'

medium

A. Hello printed immediately, then 'Task done' printed later

B. Only 'Hello' is printed, 'Task done' never prints

C. Both 'Hello' and 'Task done' print at the same time

D. SyntaxError because Thread is used incorrectly

Solution

1. Step 1: Understand thread behavior in Flask route

   The route starts a thread to run background_task, then returns 'Hello' immediately.

2. Step 2: Predict output order

   'Hello' is sent to user right away; 'Task done' prints later when thread runs.

3. Final Answer:

   Hello printed immediately, then 'Task done' printed later -> Option A

4. Quick Check:

   Thread runs task after response = A [OK]

Hint: Thread runs task after response, so print order differs [OK]

Common Mistakes:

• Thinking 'Task done' prints before 'Hello'
• Assuming thread blocks response
• Believing thread syntax is wrong here

4. What is wrong with this Flask code that tries to run a background task?

from threading import Thread
from flask import Flask
app = Flask(__name__)
def task():
    print(app.name)
@app.route('/')
def index():
    Thread(target=task).start()
    return 'Done'

medium

A. Route function must return JSON, not string.

B. The background thread lacks Flask app context, causing errors.

C. Flask app cannot print its name inside a thread.

D. Thread target function must be called with parentheses.

Solution

1. Step 1: Identify Flask app context issue

   Background threads don't have Flask app context by default, so accessing app.name can fail.

2. Step 2: Understand context handling

   To fix, use app.app_context() inside the thread to provide context.

3. Final Answer:

   The background thread lacks Flask app context, causing errors. -> Option B

4. Quick Check:

   Missing app context in thread = D [OK]

Hint: Background threads need app context to access Flask variables [OK]

Common Mistakes:

• Calling target function instead of passing it
• Thinking Flask disallows printing app.name
• Believing route must return JSON always

5. You want to run a long task asynchronously in Flask and update a database after it finishes. Which approach correctly ensures Flask app context is available in the background task?

hard

A. Use with app.app_context(): inside the background task function.

B. Call the background task directly inside the route without threading.

C. Start the thread without any context handling; Flask shares context automatically.

D. Use app.run() inside the background task to get context.

Solution

1. Step 1: Recall Flask app context rules

   Background tasks need explicit app context to access Flask features like database.

2. Step 2: Identify correct context usage

   Using with app.app_context(): inside the task ensures context is active during task execution.

3. Step 3: Eliminate incorrect options

   Calling task directly blocks request; Flask does not share context automatically; app.run() starts server, not context.

4. Final Answer:

   Use with app.app_context(): inside the background task function. -> Option A

5. Quick Check:

   Use app.app_context() in thread = B [OK]

Hint: Wrap background code with app.app_context() to access Flask features [OK]

Common Mistakes:

• Running task directly blocking the app
• Assuming Flask shares context automatically
• Misusing app.run() inside tasks