How Would You Make This Python Dictionary Thread-safe?

I have a Web Server running in Python. The server is private, so i only expect around 20 users to connect to it. The server is multi-threaded (8 cores at the moment, so 8 threads I

Solution 1:

You'll need to create a global lock object.

lock = threading.Lock()

Then around each access of the dictionary acquire and release the lock. The simplest way to do this is with the new(ish) with syntax.

with lock:
    dict[key] = value

Solution 2:

You may or may not need to use a lock, depending on how the Boolean is updated.

If the value of the Boolean doesn't depend on its previous value, then no lock is needed: writing and reading a Python dictionary is thread-safe by itself (except: writing while iterating is not allowed - but that's not allowed in single thread either). The memory visibility is similar to what would be achieved using volatile in some languages.

What's inherently not thread-safe is the "read-modify-write" -sequence, resulting in a race condition. If the value of the Boolean does depend on its previous value, then you have to use a lock, because otherwise thread A could first read the value, then thread B could change it, and then A would change it again, based on outdated value to start with.

Solution 3:

If you need a lock (to avoid the race conditions Joonas described), and are stuck with Python 2.4,

import threading
lock = threading.Lock()

shared_dict = {}

def do_thing(user, value):
    lock.acquire()
    try:
        shared_dict[user] = value
    finally:
        # Always called, even if exception is raised in try block
        lock.release()

Solution 4:

Use threading.LOCK.acquire() before updating the dictionary and use threading.LOCK.release(), once you are done updating it.

Solution 5:

You don´t need to lock dictionary to this operation, because this operation is atomic, and GIL take care this for you. Unless you have operations like read-change-write, don't worry.