Forklar locks, mutexes, critical sections og semaphores.

Question

IT Interview Practice · Accepted Answer

**En mutex er en lock, der garanterer gensidig udelukkelse — kun én tråd kan holde den og gå ind i den beskyttede critical section ad gangen.** En semaphore generaliserer dette til at tillade op til N samtidige holdere.

## Hvordan det fungerer

- **Critical section**: kodeområdet, der rører delt state og ikke må køre samtidigt.
- **Mutex (mutual exclusion)**: tag den før sektionen, frigiv efter. En anden tråd blokerer, indtil den er ledig. Ejes typisk af den trådende, der tog den (kun den må frigive).
- **Semaphore**: holder en tæller på N permits. `acquire()` dekrementerer (blokerer ved 0), `release()` inkrementerer. En mutex er i bund og grund en semaphore med N=1, men med ejerskabssemantik.

```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(...)
```

## Faldgruber

- **At glemme at frigive** → permanent blokering. Brug `with`/RAII/`defer`, så frigivelse sker automatisk selv ved exceptions.
- **At holde en lock for længe** dræber throughput; hold critical sections små.
- **Lock-granularitet**: én grovkornet lock er simpel, men serialiserer alt; mange finkornede locks skalerer bedre, men risikerer deadlock.

## Hvorfor det betyder noget

Dette er de daglige værktøjer til at beskytte delt state. Mutexes serialiserer adgang for at forhindre races; semaphores begrænser en ressourcepulje (forbindelser, permits, rate limits). At vælge den rigtige primitive og holde critical sections korte er forskellen mellem korrekt-og-hurtig og korrekt-men-langsom.

Hvordan det fungerer

Faldgruber

Hvorfor det betyder noget

Relaterede spørgsmål