Do you think a Python dictionary is thread safe?

Python dictionaries have limited thread safety due to the Global Interpreter Lock (GIL). While basic operations are atomic, complex operations and concurrent modifications can still cause issues in multi-threaded environments.

Understanding Python's GIL

The Global Interpreter Lock (GIL) ensures that only one thread executes Python bytecode at a time. This provides some level of thread safety for built-in data structures like dictionaries, but it's not complete protection.

Thread-Safe Operations

These dictionary operations are generally atomic and thread-safe ?

import threading
import time

shared_dict = {'count': 0}

def increment_count():
    for i in range(1000):
        shared_dict['count'] += 1

# Single operation - relatively safe
threads = []
for i in range(2):
    t = threading.Thread(target=increment_count)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"Final count: {shared_dict['count']}")

Final count: 2000

Thread-Unsafe Scenarios

However, compound operations can lead to race conditions ?

import threading

shared_dict = {}

def unsafe_update():
    for i in range(1000):
        # This is NOT atomic - check then modify
        if 'count' not in shared_dict:
            shared_dict['count'] = 0
        shared_dict['count'] += 1

threads = []
for i in range(3):
    t = threading.Thread(target=unsafe_update)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"Unsafe count: {shared_dict.get('count', 0)}")
print("Expected: 3000, but result may vary due to race conditions")

Unsafe count: 3000
Expected: 3000, but result may vary due to race conditions

Safe Multi-Threading with Locks

Use threading locks for guaranteed thread safety ?

import threading

shared_dict = {}
lock = threading.Lock()

def safe_update():
    for i in range(1000):
        with lock:
            if 'count' not in shared_dict:
                shared_dict['count'] = 0
            shared_dict['count'] += 1

threads = []
for i in range(3):
    t = threading.Thread(target=safe_update)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

print(f"Safe count: {shared_dict['count']}")

Safe count: 3000

Thread Safety Comparison

Conclusion

Python dictionaries are partially thread-safe due to the GIL, but compound operations require explicit locking. For guaranteed thread safety in multi-threaded applications, always use threading.Lock() or consider thread-safe alternatives like queue.Queue.