Explică lock-urile, mutex-urile, secțiunile critice și semafoarele.

Question

IT Interview Practice · Accepted Answer

**Un mutex este un lock care garantează excluderea mutuală — un singur thread îl poate deține și intra în secțiunea critică protejată odată.** Un semafor generalizează asta pentru a permite până la N deținători concurenți.

## Cum funcționează

- **Secțiune critică**: regiunea de cod care atinge starea partajată și nu trebuie să ruleze concurent.
- **Mutex (mutual exclusion)**: achiziționează înainte de secțiune, eliberează după. Un al doilea thread se blochează până e liber. De obicei deținut de thread-ul care l-a achiziționat (doar el îl poate elibera).
- **Semafor**: ține un contor de N permise. `acquire()` decrementează (se blochează la 0), `release()` incrementează. Un mutex este în esență un semafor cu N=1, dar cu semantică de deținere.

```python
lock = threading.Lock()
def transfer(a, b, amt):
    with lock:                 # secțiune critică — un thread odată
        a.balance -= amt
        b.balance += amt

# Semafor: limitează conexiunile DB concurente la 10
sem = threading.Semaphore(10)
def query():
    with sem:                  # până la 10 thread-uri rulează asta concurent
        db.execute(...)
```

## Capcane

- **Uitarea eliberării** → blocare permanentă. Folosește `with`/RAII/`defer` ca eliberarea să fie automată chiar și la excepții.
- **Ținerea unui lock prea mult timp** ucide throughput-ul; menține secțiunile critice mici.
- **Granularitatea lock-ului**: un lock grosier e simplu, dar serializează totul; multe lock-uri fine scalează mai bine, dar riscă deadlock.

## De ce contează

Acestea sunt uneltele de zi cu zi pentru protejarea stării partajate. Mutex-urile serializează accesul pentru a preveni race-urile; semafoarele limitează un pool de resurse (conexiuni, permise, rate limits). Alegerea primitivei potrivite și menținerea secțiunilor critice scurte fac diferența dintre corect-și-rapid și corect-dar-lent.

Cum funcționează

Capcane

De ce contează

Întrebări conexe