Förklara lås, mutexar, kritiska sektioner och semaforer.

Question

IT Interview Practice · Accepted Answer

**En mutex är ett lås som garanterar ömsesidig uteslutning (mutual exclusion) — bara en tråd kan hålla det och gå in i den skyddade kritiska sektionen åt gången.** En semafor generaliserar detta till att tillåta upp till N samtidiga innehavare.

## Hur det fungerar

- **Kritisk sektion**: kodregionen som rör delat tillstånd och inte får köras samtidigt.
- **Mutex (mutual exclusion)**: ta lås före sektionen, släpp efter. En andra tråd blockerar tills det är ledigt. Ägs vanligtvis av den tråd som tog det (bara den får släppa).
- **Semafor**: håller en räknare med N tillstånd (permits). `acquire()` minskar (blockerar vid 0), `release()` ökar. En mutex är i grunden en semafor med N=1 men med ägarsemantik.

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

## Fallgropar

- **Att glömma att släppa** → permanent blockering. Använd `with`/RAII/`defer` så att frisläppning sker automatiskt även vid undantag.
- **Att hålla ett lås för länge** dödar genomströmningen; håll kritiska sektioner små.
- **Låsgranularitet**: ett grovt lås är enkelt men serialiserar allt; många fina lås skalar bättre men riskerar deadlock.

## Varför det är viktigt

Detta är de vardagliga verktygen för att skydda delat tillstånd. Mutexar serialiserar åtkomst för att förhindra races; semaforer stryper en resurspool (anslutningar, tillstånd, rate limits). Att välja rätt primitiv och hålla kritiska sektioner korta är skillnaden mellan korrekt-och-snabbt och korrekt-men-långsamt.

Hur det fungerar

Fallgropar

Varför det är viktigt

Relaterade frågor