तपाईं साझा अवस्था (shared state) को पहुँच कसरी समन्वय गर्नुहुन्छ?

Question

Accepted Answer

**Synchronization** ले threads को साझा mutable state मा पहुँचलाई समन्वय गर्छ ताकि operations खतरनाक तरिकाले आपस मा न मिसिन, **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 ले एक समयमा protected code execute गर्छ (mutual exclusion) र **visibility** प्रदान गर्छ — एक thread को परिवर्तनहरु अन्यहरुलाई दृश्यमान हुन्छ (यो memory barrier पार गर्छ)।

## volatile — visibility without 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` ले guarantee गर्छ कि एक variable को reads/writes threads भर दृश्यमान छन् — तर 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 — more 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` ले `synchronized` को कमी हुने features प्रदान गर्छ: `tryLock()` (non-blocking), timed waits, fairness, र read-write separation।

## The dangers to manage

```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 ले साझा mutable state मा पहुँच गर्छन् — यो बिना, race conditions ले data को corruption र intermittent, लगभग debug गर्न असम्भव failures उत्पन्न गर्छ।

साधनहरु र तिनका precise guarantees को बुझ्नु महत्त्वपूर्ण छ: `synchronized` (mutual exclusion + visibility), `volatile` (visibility मात्र — NOT atomicity, एक सामान्य गलतफहमी), atomic classes (simple operations को लागि lock-free), र explicit Locks (advanced control)।

समान रूपमा महत्त्वपूर्ण छ dangers को बुझ्नु — **deadlock** र over-synchronization ले performance लाई हानी गर्छ — र minimal र consistently synchronize गर्ने discipline।

यो concurrent server-side Java को लागि core, high-stakes ज्ञान हो र एक गहिरो interview विषय हो जसले developers लाई अलग्गै गर्छ जसले सही multithreaded code लेख्न सक्छन्।