Unawiana vipi ufikiaji wa hali inayoshirikiwa?

Question

Accepted Answer

**Synchronization** huratibu ufikiaji wa threads wa hali inayoshirikiwa inayoweza kubadilishwa ili operesheni zisiingiliane kwa hatari, ikizuia **race conditions**. Java hutoa mbinu kadhaa, kuanzia neno muhimu lililojengwa ndani `synchronized` hadi locks za wazi na atomics zisizo na locks.

## synchronized — kutengwa kwa pande zote (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` huhakikisha thread moja tu hutekeleza msimbo unaolindwa kwa wakati mmoja (mutual exclusion) na hutoa **visibility** — mabadiliko ya thread moja huonekana kwa nyingine (huvuka memory barrier).

## volatile — visibility bila 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` huhakikisha kuwa kusoma/kuandika kwa variable kunaonekana katika threads — lakini **HAIFANYI** operesheni za mchanganyiko (kama `count++`) kuwa atomic. Itumie kwa flags rahisi, si kwa read-modify-write.

## Atomic classes — atomicity bila locks

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

Atomic classes hutoa operesheni salama kwa threads bila locks — mara nyingi haraka kuliko `synchronized` kwa counters/accumulators rahisi.

## Explicit Locks — udhibiti zaidi

```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` hutoa vipengele ambavyo `synchronized` haina: `tryLock()` (isiyozuia), timed waits, fairness, na utengano wa read-write.

## Hatari za kudhibiti

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

## Kwa nini ni muhimu

Synchronization ni muhimu kwa usahihi wakati wowote threads nyingi zinafikia hali inayoshirikiwa inayoweza kubadilishwa — bila hiyo, race conditions huzalisha data iliyoharibika na hitilafu za vipindi, ngumu sana ku-debug.

Kujua zana na dhamana zake sahihi ni muhimu: `synchronized` (mutual exclusion + visibility), `volatile` (visibility tu — SI atomicity, mkanganyiko wa kawaida), atomic classes (zisizo na locks kwa operesheni rahisi), na Locks za wazi (udhibiti wa hali ya juu).

Muhimu vilevile ni kuelewa hatari — **deadlock** na over-synchronization inayoharibu utendaji — na nidhamu ya kuwianisha kwa kiwango kidogo na kwa uthabiti.

Hii ni maarifa ya msingi, ya hatari kubwa kwa Java ya upande wa server inayofanya kazi pamoja na ni mada ya kina ya mahojiano inayotofautisha developers wanaoweza kuandika msimbo sahihi wa multithreaded.