Explain locks, mutexes, critical sections, and semaphores.

Question

IT Interview Practice · Accepted Answer

**mutex అనేది mutual exclusion ను హామీ ఇచ్చే ఒక lock — ఒక సమయంలో ఒకే thread దాన్ని పట్టుకుని రక్షిత critical section లోకి ప్రవేశించగలదు.** semaphore దీన్ని N concurrent holders వరకు అనుమతించేలా సాధారణీకరిస్తుంది.

## ఇది ఎలా పనిచేస్తుంది

- **Critical section**: shared state ను తాకే మరియు concurrent గా run అవ్వకూడని code ప్రాంతం.
- **Mutex (mutual exclusion)**: section కు ముందు acquire చేయండి, తర్వాత release చేయండి. అది free అయ్యే వరకు రెండవ thread block అవుతుంది. సాధారణంగా acquire చేసే thread కు స్వంతం (అది మాత్రమే release చేయగలదు).
- **Semaphore**: N permits యొక్క counter ను కలిగి ఉంటుంది. `acquire()` తగ్గిస్తుంది (0 వద్ద block అవుతుంది), `release()` పెంచుతుంది. mutex అనేది ప్రాథమికంగా N=1 తో ఉన్న semaphore కానీ 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

- **release చేయడం మర్చిపోవడం** → శాశ్వత block. exceptions పై కూడా release స్వయంచాలకంగా జరిగేలా `with`/RAII/`defer` ను ఉపయోగించండి.
- **lock ను చాలా సేపు పట్టుకోవడం** throughput ను చంపుతుంది; critical sections ను చిన్నగా ఉంచండి.
- **Lock granularity**: ఒక coarse lock సరళం కానీ ప్రతిదాన్ని serialize చేస్తుంది; అనేక fine locks మెరుగ్గా scale అవుతాయి కానీ deadlock ప్రమాదం ఉంటుంది.

## ఇది ఎందుకు ముఖ్యం

shared state ను రక్షించడానికి ఇవి రోజువారీ tools. Mutexes races ను నివారించడానికి access ను serialize చేస్తాయి; semaphores ఒక resource pool (connections, permits, rate limits) ను నియంత్రిస్తాయి. సరైన primitive ను ఎంచుకోవడం మరియు critical sections ను చిన్నగా ఉంచడం correct-and-fast మరియు correct-but-slow మధ్య తేడా.

ఇది ఎలా పనిచేస్తుంది

Pitfalls

ఇది ఎందుకు ముఖ్యం

సంబంధిత ప్రశ్నలు