Rääkige võistluse tingimusest (race condition) ja…

Jooksu olekord on mitmeprotsessisüsteemi disaini viga, mille tulemus sõltub koodiosade täitmise järjekorrast erinevates lõimes. See juhtub, kui mitu lõime pääsevad samaaegselt juurde jagatud muutumatule ressursile ilma nõuetekohase sünkroneerimiseta.

Jooksu oleku vältimiseks Java-s kasutatakse järgmisi lähenemisviise:

Sünkroneeritud meetodite ja plokkide kasutamine:

class Counter {
    private int count = 0;

    // Sünkroneeritud meetod
    public synchronized void increment() {
        count++;
    }

    // Sünkroneeritud plokk
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
}

Sõna synchronized tagab, et ainult üks lõim saab samaaegselt täita sünkroneeritud koodi selle objekti (või klassi, kui meetod on staatiline) jaoks.

Lock klassi kasutamine java.util.concurrent.locks paketist:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SafeCounter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // Lukustuse haaramine
        try {
            count++;
        } finally {
            lock.unlock(); // Lukust vabastamine
        }
    }
}

Lock pakub paindlikumaid lukustusmehhanisme võrreldes synchronized-ga.

Aatomaarsete muutujate kasutamine java.util.concurrent.atomic paketist:

import java.util.concurrent.atomic.AtomicInteger;

class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // Aatomaarne operatsioon
    }
}

Aatomaarsed muutujad võimaldavad teostada operatsioone (näiteks inkrement, dekrement), mis toimuvad kui üks tervik ja mida ei saa katkestada teise lõime poolt.

Mitme lõime turvalised kogumikud java.util.concurrent paketist: Näiteks ConcurrentHashMap, CopyOnWriteArrayList. Need kogumikud on loodud mitmelõimelise kasutamise jaoks.
Ühise muutuva oleku vältimine: Kui võimalik, tuleks andmed, mis on kättesaadavad mitmele lõimile, muuta muutumatuks (immutable) või eraldada iga lõime jaoks.
volatile kasutamine: Sõna volatile tagab muutujate nähtavuse kõigi lõimede jaoks, kuid ei taga operatsioonide atomilisust (välja arvatud primitiivsete tüüpide lugemine ja kirjutamine, välja arvatud long ja double, ning viited). See on kasulik koos teiste mehhanismidega või lihtsate, olekust sõltumatute operatsioonide puhul.
```
class VolatileFlag {
    volatile boolean flag = false; // Nähtavuse garantii

    public void setFlag() {
        flag = true;
    }

    public boolean isFlag() {
        return flag;
    }
}
```

Valik sobivast meetodist sõltub konkreetsest olukorrast ning nõuetest jõudluse ja keerukuse osas.

Rääkige võistluse tingimusest (race condition) ja kuidas seda vältida mitmetuumalistes rakendustes.