Conas a dhéanann tú inneachar roinnte a dhúghluaiseachán?

Question

Accepted Answer

**An Síochronú** comhordaíonn rochtain snáitheanna ar inneachar inathraitheach roinnte ionas nach dtéann oibríochtaí i ngreime ina chéile go contúirteach, agus **coinníollacha rása** á chosc. Soláthraíonn Java roinnt meicníochtaí, ó an bhfocal-eochairí `synchronized` ionsuite go glasanna soiléir agus adamhach gan ghlas.

## synchronized — eisiamáint dhúbailte (glasanna iontuigthe)

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

Cinntíonn `synchronized` nach bhfuil ach snáithe amháin ag feidhmiú an chód cosanta ag an am céanna (eisiamáint dhúbailte) agus soláthraíonn **infheictheacht** — bíonn athruithe snáithe amháin infheicthe do na cinn eile (trasnaíonn sé an bacainn cuimhne).

## volatile — infheictheacht gan atomúlacht

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

Ráthaíonn `volatile` go bhfuil léamha/scríobh athróige infheicthe ar fud snáitheanna — ach **NÍL** sé ina dhéanann oibríochtaí cumaisc (ar nós `count++`) adamhach. Úsáid é do bhratáin shimplí, ní le haghaidh léamh-athraithe-scríobh.

## Ranganna Atomic — adamúlacht gan ghlas

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

Soláthraíonn ranganna Atomic oibríochtaí snáithe-sábháilte gan ghlas — go minic níos tapúla ná `synchronized` do chunntairí/carnacháin shimplí.

## Glasanna Soiléir — níos mó rialaithe

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

Cuireann `ReentrantLock` ar fáil gné nach bhfuil ag `synchronized`: `tryLock()` (neamhbhacach), fanacht dhréimhseach, cothromáint agus scaradh léamh-scríobh.

## Na contúirtí le bhainistiú

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

## Cén fáth a bhíonn sé tábhachtach

Tá síochronú riachtanach le haghaidh ceartais nuair a bhíonn rochtain ag snáitheanna iolracha ar inneachar inathraitheach roinnte — gan é, táirgeann coinníollacha rása sonraí truaillithe agus faillí eatramhéadacha, beagnach dodhéanta a dhífhabhtú.

Tá sé criticiúil eolas na dtúl agus a nráthaíonn cruinn a bheith agat: `synchronized` (eisiamáint dhúbailte + infheictheacht), `volatile` (infheictheacht amháin — NÍL atomúlacht ann, malúinterpréadh coitianta), ranganna Atomic (gan ghlas do oibríochtaí simplí) agus Glasanna Soiléir (rialaithe fioruáltha).

Tá sé chomh tábhachtach sin an bhéim ar an contúirtí — **dúntas** agus for-dhúghluaiseachán a dhéanann damáiste don fheidhmíochán — agus an disciplín a dhúghluaiseachán ar an íosbhealach agus go comhsheasmhach.

Is eolas bunúsach, an-ard-riosca seo atá ann, do Java comhthagartha taobh an fhrithealaí agus ábhar doimhin agus doimhin a bhíonn i gceist a dhéanann deighilt ar fhorbróirí ar féidir leo cód fairsing a scríobh go ceart.