Miks tekiliste võistlused tekivad ja millised on…

Voolu võistlused (race conditions) tekivad, kui mitu lõime pöörduvad samaaegselt ühiste muudetavate andmete poole ning nende täitmise tulemus sõltub nende täitmise järjekorrast. See toimub seetõttu, et operatsioonisüsteem võib vahetada lõime mis tahes hetkel, katkestades nende täitmise.

Võistluste viisid:

Sünkroniseerimine: Sünkroniseerimisprimitiivide kasutamine, et tagada eksklusiivne juurdepääs ühistele ressurssidele.

synchronized märksõna: Seda kasutatakse meetodite või koodiblokkide sünkroniseerimiseks. See blokeerib juurdepääsu objekti või klassi teistele lõimedele, kuni praegune lõim lõpetab sünkroniseeritud ploki/metodi.

// Sünkroniseeritud meetod
public synchronized void updateData(int newValue) {
    // ... ühiste andmete uuendamine
}

// Sünkroniseeritud koodibloki näide
public void processData() {
    synchronized (this) { // Või mõni muu monitorobjekt
        // ... juurdepääs ühistele andmetele
    }
}

Lukud (Lock): Pakuvad paindlikumat kontrolli sünkroniseerimise üle võrreldes synchronized-ga.

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

private final Lock dataLock = new ReentrantLock();

public void safeUpdateData(int newValue) {
    dataLock.lock(); // Luku haaramine
    try {
        // ... ühiste andmete uuendamine
    } finally {
        dataLock.unlock(); // Luku vabastamine
    }
}

Atomaarsed muutujad (Atomic...): Pakuvad lõimedele turvalisi operatsioone primitiivsete tüüpide üle ilma selge lukustamiseta. Kasutatakse lihtsateks operatsioonideks (inkrement, võrdlus ja vahetamine).

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger counter = new AtomicInteger(0);

public void incrementCounter() {
    counter.incrementAndGet(); // Atomaalne suurendamine
}

Lõimeturvalised kogumikud: Kasutades spetsiaalseid kogusid paketist java.util.concurrent (näiteks ConcurrentHashMap, CopyOnWriteArrayList), mis on loodud mitme lõime juurdepääsuks.
```
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

private final Map<String, Integer> safeMap = new ConcurrentHashMap<>();
```
Muutumatud (Immutable) objektid: Kui andmed ei muutu pärast loomist, saab nendega turvaliselt töötada mitme lõime poolt ilma sünkronisatsioonita.

Lõimispõhised muutujad (ThreadLocal): Iga lõimel on oma koopia muutujast, mis väldib konkurentsi juurdepääsu osas.

private final ThreadLocal<Integer> threadId = new ThreadLocal<>();

public void setThreadId() {
    threadId.set(Thread.currentThread().getId());
}

public int getThreadId() {
    return threadId.get();
}

Õige arhitektuuri disain: Minimeerida ühiseid muutuvaid andmeid ning kasutada asünkroonseid lähenemisviise või sõnumite edastamist lõimede vahel, et vähendada võistlusi.

Miks tekiliste võistlused tekivad ja millised on nende vastu võitlemise viisid?