Kāpēc notiek pavedienu sacensības un kādi ir to cīņas…

Riteņu sacīkstes (race conditions) rodas, kad vairāki pavedieni vienlaikus piekļūst kopīgiem mainīgiem datiem, un izpildes rezultāts ir atkarīgs no to izpildes secības. Tas notiek tāpēc, ka operētājsistēma var pārslēgt pavedienus jebkurā brīdī, pārtraucot to izpildi.

Cīņas veidi:

Sinhronizācija: Sinhronizācijas primitīvu izmantošana, lai nodrošinātu ekskluzīvu piekļuvi kopīgiem resursiem.

synchronized atslēgvārds: To lieto metožu vai koda bloku sinhronizācijai. Tas bloķē piekļuvi objektam vai klasei citiem pavedieniem, kamēr pašreizējais pavediens nepabeidz sinhronizēto bloku/metodi.

// Sinhronizācijas metode
public synchronized void updateData(int newValue) {
    // ... kopīgo datu atjaunināšana
}

// Sinhronizācijas koda bloka piemērs
public void processData() {
    synchronized (this) { // Vai jebkurš cits monitor objekts
        // ... piekļuve kopīgajiem datiem
    }
}

Bloķēšanas (Lock): Sniedz elastīgāku kontroli pār sinhronizāciju salīdzinājumā ar synchronized.

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(); // Bloķēšanas iegūšana
    try {
        // ... kopīgo datu atjaunināšana
    } finally {
        dataLock.unlock(); // Bloķēšanas atbrīvošana
    }
}

Atomārie mainīgie (Atomic...): Nodrošina pavedienu drošas operācijas ar primitivajiem datu tipiem bez skaidras bloķēšanas. Tos izmanto vienkāršām operācijām (inkrementēšana, salīdzināšana un maiņa).

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger counter = new AtomicInteger(0);

public void incrementCounter() {
    counter.incrementAndGet(); // Atomiska palielināšana
}

Pavedienu drošas kolekcijas: Izmanto īpašas kolekcijas no pakotnes java.util.concurrent (piemēram, ConcurrentHashMap, CopyOnWriteArrayList), kas izstrādātas daudzpavedienu piekļuvei.
```
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

private final Map<String, Integer> safeMap = new ConcurrentHashMap<>();
```
Nemainīgas (Immutable) objekti: Ja dati nemainās pēc to izveides, tad tiem var droši piekļūt no vairākiem pavedieniem bez sinhronizācijas.

Vietējo pavedienu mainīgo (ThreadLocal): Katram pavedienam tiek piešķirta sava mainīgā kopija, kas novērš konkurenci piekļuvei.

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

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

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

Pareiza arhitektūras dizaina izstrāde: Minimizēt kopīgos mainīgos datus un izmantot asīnhroniskas pieejas vai ziņojumu nodošanu starp pavedieniem, lai samazinātu sacensību iespējamību.

Kāpēc notiek pavedienu sacensības un kādi ir to cīņas veidi?