Explain locks, mutexes, critical sections, and semaphores.

Question

IT Interview Practice · Accepted Answer

**A mutex is a lock that guarantees mutual exclusion — only one thread can hold it and enter the protected critical section at a time.** A semaphore generalizes this to allow up to N concurrent holders.

## How it works

- **Critical section**: the code region that touches shared state and must not run concurrently.
- **Mutex (mutual exclusion)**: acquire before the section, release after. A second thread blocks until it's free. Typically owned by the acquiring thread (only it may release).
- **Semaphore**: holds a counter of N permits. `acquire()` decrements (blocks at 0), `release()` increments. A mutex is essentially a semaphore with N=1 but with ownership semantics.

```python
lock = threading.Lock()
def transfer(a, b, amt):
    with lock:                 # critical section — one thread at a time
        a.balance -= amt
        b.balance += amt

# Semaphore: cap concurrent DB connections at 10
sem = threading.Semaphore(10)
def query():
    with sem:                  # up to 10 threads run this concurrently
        db.execute(...)
```

## Pitfalls

- **Forgetting to release** → permanent block. Use `with`/RAII/`defer` so release is automatic even on exceptions.
- **Holding a lock too long** kills throughput; keep critical sections small.
- **Lock granularity**: one coarse lock is simple but serializes everything; many fine locks scale better but risk deadlock.

## Why it matters

These are the everyday tools for protecting shared state. Mutexes serialize access to prevent races; semaphores throttle a resource pool (connections, permits, rate limits). Choosing the right primitive and keeping critical sections short is the difference between correct-and-fast and correct-but-slow.

How it works

Pitfalls

Why it matters

Related questions