Synchronisation (locks, semaphores)

When two threads read and write shared data at the same time, the result can depend on exact timing. This is a race condition. The piece of code that touches the shared data is the critical section, and it must not be run by two threads at once.

A mutex (lock) lets exactly one thread into a critical section at a time. A semaphore is a counter: wait (P) decrements it and blocks at zero, signal (V) increments it and wakes a waiter, so a semaphore of 3 lets up to 3 threads in. A condition variable lets a thread sleep until some condition becomes true, always used together with a mutex. Spinlocks busy-wait instead of sleeping, and atomic operations (like compare-and-swap) update a single value safely without a lock.

1. 1Identify shared mutable state: any variable, object or file that more than one thread can change.
2. 2Find the critical section: the smallest block of code that reads and then writes that state and must happen as one step.
3. 3Protect it: acquire a mutex before, release after (ideally with a 'with' block or try/finally so it is released even on errors). Only the owner releases a mutex.
4. 4Use a counting semaphore when you need to limit concurrency to N (for example N database connections), not exclusive access.
5. 5Use a condition variable when a thread must wait for a state change (queue not empty): lock, check the condition in a while loop, wait (which releases the lock while sleeping), and re-check after waking.
6. 6Prefer higher-level tools when possible: thread-safe queues, atomic counters, or immutable data that never needs locking.

import threading

counter = 0
lock = threading.Lock()

def add(n):
    global counter
    for _ in range(n):
        with lock:               # only one thread in the critical section
            counter += 1         # read-modify-write is not atomic

threads = [threading.Thread(target=add, args=(100_000,)) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()
print(counter)                   # always 400000

# A counting semaphore limits how many threads enter, instead of one.
db_slots = threading.Semaphore(3)

def run_query(sql):
    with db_slots:               # at most 3 queries at the same time
        ...                      # use one of 3 database connections

The lock makes the read-modify-write of counter a single step from other threads' point of view, so four threads adding 100,000 each always give 400,000. Without the lock, updates can be lost. The semaphore allows up to three concurrent queries instead of one.

Cost: An uncontended lock is cheap (often tens of nanoseconds); a contended lock forces waiting and context switches, so throughput falls as contention rises.