Paano ka magsasabay ng access sa haati na Estado?

Question

Accepted Answer

**Synchronization** tare da haƙowar zane-zane zuwa jihar haɓakacin gaske kaɗai don haka ayyuka ba sa sanye su da sanyi ba, ta guje race conditions. Java ya ba da nuwanin sakamakon, daga mahimmancin `synchronized` zuwa iskar sharai da 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` yana tabbatar da cewa zane daya ne kawai ke aiki da kodi mai kariya a lokaci gida (mutual exclusion) kuma ya samar da **visibility** — canje-canje ta zane ɗaya ya zama ganin wasu (yana ketare wutar memory).

## 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` yana tabbatar da cewa karatun/rubuti na mai canja-canja ke ganewa a gida - amma **BA** yana sa ayyuka na haɗa-haɗa (kamar `count++`) atomic. Yi amfani da shi don m-flags na sauki, ba don karatu-canja-rubuta.

## 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 suna samar da ayyukan jiyya-safe ba tare da sarƙoƙi ba — sau da yawa sauri fiye da `synchronized` don adadi-gida masu sauki.

## 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` yana ba da alamun da `synchronized` ba shi da shi: `tryLock()` (ba-dace), lokaci-jiya, adalci, da bambanta-karatu-rubuta.

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

## Yaya ya zama mahimmanci

Synchronization shi ne mahimmanci don daidaito duk lokacin da zane-zane da yawa ke shiga haitan jihar haɓakacin gaske - ba tare da shi ba, race conditions suna haifar da data mai lahani da falle-fallensa, kusan ba-debug na wala.

Sanin kayan aiki da niyayinsu na gida shi ne mahimmanci: `synchronized` (mutual exclusion + visibility), `volatile` (visibility ne kawai - BA atomicity, karya-tunanin gida) atomic classes (lock-free don sauki ops) da Explicit Locks (cin gida c-sakamako).

Daidai mahimmanci kuma shi ne fahimtar metuttukan - **deadlock** da over-synchronization damun karfi - da ƙwalliya na sakamako sauki da dace-dace.

Wancan shine mahimmancin-jiya, babbar fahimta don haɗa-haɗa-jiya Java kuma zafin shaƙi na waje da ke bambanta masu bada jiya wanda zai iya rubuta kodi-jiya daidai.