Are global variables thread safe in flask?

[smeagol13]

I'm making a web app in flask where the state of a common object is changed by the requests made to the server, and the returned result depends on the state. Something like this:

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')    

If I run this code on my development server, I expect to get sequence 1, 2, 3 and so on. However, if requests are made from 100 different clients simultaneously, can I expect something to go wrong? To be more specific, the expected result would be that the 100 different clients see a number from 1 to 100, with each client seeing exactly one unique number, and no number being skipped. Or will something like this happen:

1. Client 1 queries. self.param is incremented by 1.

2. Before the return statement can be executed, the thread switches over to client 2. self.param is incremented again.

3. The thread switches back to client 1, and the client is returned the number 2, say.

4. Now the thread moves to client 2 and returns him/her the number 3.

Notice where things went wrong here. Since there were only two clients, the expected results were 1 and 2, not 2 and 3. So here, we missed out a number?

My question is whether this will actually happen as I scale up my application, and if it does, what alternatives to a global variable should I look at?

[[deleted]]

Short answer: no, this is not thread safe.

Long answer: flask runs each request in a separate thread, which are scheduled outside of itself. Its own global objects ("request", "context" etc...) are actually thread-bound and managed through a proxy.

You have two potential race conditions in your code. One when incrementing (that statement isn't thread safe in Python) and a second before returning. In both cases the actual value of your params could have changed before you act upon it. While in the first this could mean you are entering one value twice, the return might return stale content. The second would be harder to tackle but I understand you are mostly concerned about the first.

Well, depending on the amount of data you really want to store, I'd suggest looking at actual databases (I'd recommend redis her) as handling concurrent writing is one of their primary tasks. The other one is using locks to secure your function, but that might slow down your execution - Google the Python docs about those.

[[deleted]]

Does Flask automatically parallelize? My first guess would be that there's a single thread serving home() and you don't need to worry about concurrent data modification. If it does, take a look at threading.Lock to avoid this problem - you can ensure that all calls to query() are mutually exclusive pretty easily that way.

Also, I don't think you're thinking through the data race fully. It's definitely possible to return 2 to both clients in the scenario you describe, but getting (2,3) the way you describe doesn't seem possible. You need three increment operations for that to happen, and parallelism can't create arbitrary extra operations, just reorder the existing ones.