Povedzte o stave preteku (race condition) a ako sa mu…

Stav závodu je chyba v návrhu viacvláknového systému, pri ktorom výsledok vykonávania programu závisí od poradia, v akom rôzne vlákna vykonávajú časti kódu. To sa deje, keď viac vlákien súčasne pristupuje k spoločnému meniteľnému zdroju bez riadnej synchronizácie.

Na zabránenie stavu závodu v Jave sa používajú nasledujúce prístupy:

Použitie synchronizovaných metód a blokov:

class Counter {
    private int count = 0;

    // Synchronizovaná metóda
    public synchronized void increment() {
        count++;
    }

    // Synchronizovaný blok
    public void decrement() {
        synchronized (this) {
            count--;
        }
    }
}

Kľúčové slovo synchronized zabezpečuje, že len jedno vlákno môže súčasne vykonávať synchronizovaný kód pre tento objekt (alebo pre triedu, ak je metóda statická).

Použitie triedy Lock z balíka java.util.concurrent.locks:

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(); // Získanie zámku
        try {
            count++;
        } finally {
            lock.unlock(); // Uvoľnenie zámku
        }
    }
}

Lock poskytuje flexibilnejšie mechanizmy zámkov v porovnaní so synchronized.

Použitie atomických premenných z balíka java.util.concurrent.atomic:

import java.util.concurrent.atomic.AtomicInteger;

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

    public void increment() {
        count.incrementAndGet(); // Atomická operácia
    }
}

Atomické premenné poskytujú atomické operácie (napríklad, inkrementácia, dekrementácia), ktoré sa vykonávajú ako celok a nemôžu byť prerušené iným vláknom.

Použitie vláknovo bezpečných kolekcií z balíka java.util.concurrent: Napríklad, ConcurrentHashMap, CopyOnWriteArrayList. Tieto kolekcie sú navrhnuté tak, aby boli bezpečné pre použitie vo viacvláknových prostrediach.
Vyhýbanie sa spoločnému meniteľnému stavu: Ak je to možné, dáta prístupné z viacerých vlákien by mali byť nemenné (immutable) alebo oddelené pre každé vlákno.
Použitie volatile: Kľúčové slovo volatile garantuje viditeľnosť zmien v premennej pre všetky vlákna, ale nezaručuje atomickosť operácií (okrem čítania a zápisu primitívnych typov, okrem long a double, a odkazov). Je užitočné v kombinácii s inými mechanizmami alebo pre jednoduché, nezávislé operácie stavu.
```
class VolatileFlag {
    volatile boolean flag = false; // Zaručená viditeľnosť zmien

    public void setFlag() {
        flag = true;
    }

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

Výber vhodnej metódy závisí od konkrétnej situácie a požiadaviek na výkon a zložitosť kódu.

Povedzte o stave preteku (race condition) a ako sa mu dá vyhnúť v viacvláknových aplikáciách.