तुम्ही सामायिक स्थितीमध्ये प्रवेश कसे समन्वय करता?

Question

Accepted Answer

**समन्वय** सामायिक परिवर्तनशील स्थितीमध्ये धागों की पहुंच को समन्वय करता है जेणे की ऑपरेशन्स धोकाच्या दरम्यान अंतर्भुज न होते, **रेस परिस्थितीचे** प्रतिबंध करते. Java एकाधिक यंत्रणा प्रदान करते, अंतर्निर्मित `synchronized` सार्वकालिक शब्द ते स्पष्ट कुंडी व लॉक-मुक्त अणु पर्यंत.

## synchronized — पारस्परिक वर्जन (अंतर्निहित कुंडी)

```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` सुनिश्चित करते की केवळ एक धागा संरक्षित कोड एका वेळी चालवते (पारस्परिक वर्जन) आणि **दृश्यमानता** प्रदान करते — एका धाग्याच्या बदल अन्यांना दृश्यमान होतात (ते स्मृती अवरोधकाला ओलांडते).

## volatile — दृश्यमानता अणुत्व अभाव

```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` हे सुनिश्चित करते की व्हेरिएबलचे वाचन/लेखन धाग्यांमध्ये दृश्यमान आहेत — परंतु **नाही** संयुक्त ऑपरेशन्स (`count++` सारखे) अणु बनवते. सोपे ध्वज साठी वापरा, वाचन-सुधार-लेखन साठी नाही.

## अणु वर्ग — लॉक-मुक्त अणुत्व

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

अणु वर्ग कुंडी न करता धाग्य-सुरक्षित ऑपरेशन्स प्रदान करते — सोप्या मोजक/संग्राहकांसाठी अक्सर `synchronized` पेक्षा वेगवान.

## स्पष्ट कुंडी — अधिक नियंत्रण

```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` कडे नाहीत: `tryLock()` (गैर-अवरोधन), वेळ असलेली प्रतीक्षा, न्याय आणि वाचन-लेखन विभाजन.

## व्यवस्थापन करण्याचे धोके

```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
```

## हे महत्वाचे का आहे

अनेक धागे सामायिक परिवर्तनशील स्थितीमध्ये प्रवेश करतात तेव्हा सांप्रत सुदृढतेसाठी आवश्यक असते — याशिवाय, रेस परिस्थितीचे भ्रष्ट डेटा व अंतराळ, अवांतर-अशक्य-डिबग विफलता निर्माण करते.

यंत्रणा आणि त्यांच्या अचूक हमी जाणून घेणे गंभीर आहे: `synchronized` (पारस्परिक वर्जन + दृश्यमानता), `volatile` (केवळ दृश्यमानता — अणुत्व नाही, सामान्य गैरसमज), अणु वर्ग (सोप्या ऑपरेशन्ससाठी लॉक-मुक्त) व स्पष्ट कुंडी (उन्नत नियंत्रण).

तसेच महत्वाचे असे धोके समजून घेणे आहे — **अचल** आणि अतिरिक्त-समन्वय कामगिरी दुखापी — व किमान व सुसंगत समन्वय करण्याचे अनुशासन.

हे समवर्ती सर्व-बाजू Java साठी मूळ, उच्च-जोखीम ज्ञान आणि खोल मुलाखत विषय आहे जे सांख्यिक धाग्य कोड लिहिण्यास सक्षम विकसक वेगळे करते.