آپ shared state تک رسائی کو کیسے synchronize کرتے ہیں؟

Question

Accepted Answer

**Synchronization** threads کی shared mutable state تک رسائی کو منظم کرتا ہے تاکہ operations خطرناک طریقے سے interleave نہ ہوں، **race conditions** سے بچاتا ہے۔ Java متعدد mechanisms فراہم کرتا ہے، built-in `synchronized` keyword سے لے کر explicit locks اور lock-free atomics تک۔

## synchronized — mutual exclusion (intrinsic locks)

```java
class BankAccount {
    private double balance;

// synchronized method — acquires the object's lock; only ONE thread at a time
    public synchronized void withdraw(double amount) {
        if (balance >= amount) {
            balance -= amount;   // protected — no interleaving
        }
    }
    // synchronized block — finer-grained, lock on a specific object
    public void deposit(double amount) {
        synchronized (this) {
            balance += amount;
        }
    }
}
```

`synchronized` یقینی بناتا ہے کہ صرف ایک thread محفوظ شدہ code کو ایک وقت میں چلائے (mutual exclusion) اور **visibility** فراہم کرتا ہے — ایک thread کی طرف سے تبدیلیاں دوسرے threads کے لیے نظر آتی ہیں (یہ memory barrier کو cross کرتا ہے)۔

## volatile — visibility بغیر atomicity کے

```java
private volatile boolean running = true;   // guarantees VISIBILITY across threads

public void stop() { running = false; }     // other threads see the change immediately
public void run() { while (running) { ... } } // without volatile, might never see false
```

`volatile` یقینی بناتا ہے کہ ایک variable کی reads/writes threads کے دوران visible ہوں — لیکن compound operations (جیسے `count++`) کو atomic نہیں بناتا۔ اسے سادہ flags کے لیے استعمال کریں، read-modify-write کے لیے نہیں۔

## Atomic classes — lock-free atomicity

```java
AtomicInteger counter = new AtomicInteger(0);
counter.incrementAndGet();        // atomic ++ without locking (uses CPU CAS instructions)
counter.compareAndSet(5, 10);     // atomic conditional update
```

Atomic classes بغیر locks کے thread-safe operations فراہم کرتی ہیں — اکثر سادہ counters/accumulators کے لیے `synchronized` سے تیز۔

## Explicit Locks — زیادہ control

```java
ReentrantLock lock = new ReentrantLock();
lock.lock();
try {
    // critical section
} finally {
    lock.unlock();   // ALWAYS unlock in finally
}
// ReadWriteLock allows many concurrent readers but exclusive writers
```

`ReentrantLock` وہ features فراہم کرتا ہے جو `synchronized` میں نہیں ہیں: `tryLock()` (non-blocking)، timed waits، fairness، اور read-write separation۔

## خطرات کو منظم کریں

```text
⚠️ Deadlock — two threads each hold a lock the other needs → both stuck forever
   (avoid by always acquiring locks in a consistent order)
⚠️ Performance — over-synchronizing serializes everything, killing concurrency
   (synchronize the SMALLEST necessary section)
⚠️ Forgetting to unlock (with explicit Locks) → use try/finally
```

## یہ کیوں اہم ہے

Synchronization ضروری ہے صحیح کے لیے جب بھی متعدد threads shared mutable state تک رسائی حاصل کریں — اس کے بغیر، race conditions corrupted data اور intermittent، تقریباً debug کرنے کے لیے ناممکن failures پیدا کرتے ہیں۔

tools اور ان کی precise guarantees کو جاننا critical ہے: `synchronized` (mutual exclusion + visibility)، `volatile` (visibility صرف — NOT atomicity، ایک عام غلط فہمی)، atomic classes (سادہ ops کے لیے lock-free)، اور explicit Locks (advanced control)۔

برابر اہم خطرات کو سمجھنا ہے — **deadlock** اور over-synchronization performance کو نقصان پہنچاتے ہوئے — اور minimally اور consistently synchronize کرنے کی نظم و ضبط۔

یہ concurrent server-side Java کے لیے core، high-stakes knowledge ہے اور ایک گہرا interview topic ہے جو وہ developers کو الگ کرتا ہے جو correct multithreaded code لکھ سکتے ہیں۔