Milyen módszereket ismer a szálak versenyének…

Az Androidban több fő megközelítés létezik a szálak szinkronizálására és a versenyhelyzetek megelőzésére, a volatile mellett.

A synchronized használata: Lezárja a hozzáférést a kódhoz vagy metódushoz más szálak számára a jelenlegi szál befejezéséig.

// Szinkronizált metódus
synchronized void incrementCounter() {
    counter++;
}

// Szinkronizált blokk
void updateData() {
    synchronized (this) { // vagy más monitor objektum
        // szinkronizációt igénylő kód
    }
}

A java.util.concurrent.locks csomag osztályainak használata: Rugalmasabb zárolási mechanizmusokat kínálnak, mint a synchronized.

import java.util.concurrent.locks.ReentrantLock;

private final ReentrantLock lock = new ReentrantLock();

void performLockedOperation() {
    lock.lock(); // Zárolás megszerzése
    try {
        // zárolt kód
    } finally {
        lock.unlock(); // zárolás feloldása (fontos a finally-ben)
    }
}

A java.util.concurrent.atomic csomag osztályainak használata: Atomi műveleteket kínálnak, amelyek egy egységként, megszakítás nélkül hajtódnak végre más szálak által. Egyszerű műveletekhez primitív típusokon és hivatkozásokon.
```
import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger atomicCounter = new AtomicInteger(0);

void incrementAtomicCounter() {
    atomicCounter.incrementAndGet(); // Atomi növelés
}
```

Szálbiztos kollekciók használata: A java.util.concurrent csomag kollekciói (pl. ConcurrentHashMap, CopyOnWriteArrayList) biztonságosan használhatók több szálon anélkül, hogy a fejlesztőnek explicit szinkronizációt kellene alkalmaznia.

import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

private final Map<String, Integer> concurrentMap = new ConcurrentHashMap<>();

void updateMap(String key, Integer value) {
    concurrentMap.put(key, value); // biztonságos írási művelet
}

A ThreadLocal használata: Lehetővé teszi, hogy egy változó minden szál számára külön példányban legyen elérhető. Így minden szál saját adatait kezeli, elkerülve a versenyhelyzetet.

private final ThreadLocal<Integer> threadLocalValue = new ThreadLocal<Integer>() {
    @Override
    protected Integer initialValue() {
        return 0; // Kezdeti érték minden szál számára
    }
};

void processData() {
    int value = threadLocalValue.get();
    value++;
    threadLocalValue.set(value); // érték beállítása a jelenlegi szál számára
}

A módszer kiválasztása a feladat specifikációjától, zárolási szükségességétől, az adatok típusától és a teljesítményigénytől függ.

Milyen módszereket ismer a szálak versenyének kezelésére, a volatile kulcsszó használata mellett?