Are Flask's Global Variables Thread-Safe?

Are Global Variables Thread-Safe in Flask?

In Flask applications, maintaining data consistency is crucial when handling concurrent requests. Using global variables to store shared data can introduce thread safety issues.

Unsafe Use of Global Variables

Consider the following example:

class SomeObj():
    def __init__(self, param):
        self.param = param
    def query(self):
        self.param += 1
        return self.param

global_obj = SomeObj(0)

@app.route('/')
def home():
    flash(global_obj.query())
    render_template('index.html')

When multiple clients request this route simultaneously, the expected result is a unique number for each client (e.g., 1, 2, 3...). However, due to thread interleaving, the following race condition may occur:

1. Client 1 calls query(), incrementing param to 1.
2. While Client 1's request is still in progress, the thread switches to Client 2.
3. Client 2 calls query(), incrementing param to 2.
4. The thread switches back to Client 1, returning 2 instead of the expected 1.
5. Client 2 returns 3, skipping the number 2.

Alternatives to Global Variables

To avoid thread safety issues, consider the following alternatives:

• External Data Source: Use a database, memcached, or Redis to store global data outside of Flask.
• Multiprocessing.Manager: When working with Python data, use multiprocessing.Manager to share data across processes.
• Session Object: Use Flask's session object for user-specific data that needs to persist between requests.

Other Considerations

• When running the development server, thread safety issues may not be apparent due to its single-threaded nature.
• Async WSGI servers, such as gevent, do not guarantee thread safety for global variables.
• For request-specific data storage, consider using Flask's g object.

The above is the detailed content of Are Flask's Global Variables Thread-Safe?. For more information, please follow other related articles on the PHP Chinese website!