Aké spôsoby boja s pretekaním vlákien, okrem použitia…

Existuje niekoľko hlavných prístupov k synchronizácii vlákien a prevencii závodných podmienok v Androide okrem volatile.

Použitie synchronized: Zablokuje prístup ku kódu alebo metóde pre iné vlákna do ukončenia aktuálneho vlákna.

// Synchronizovaná metóda
synchronized void incrementCounter() {
    counter++;
}

// Synchronizovaný blok
void updateData() {
    synchronized (this) { // alebo iný monitorovací objekt
        // kód vyžadujúci synchronizáciu
    }
}

Použitie tried z balíka java.util.concurrent.locks: Ponúkajú flexibilnejšie mechanizmy blokovania než synchronized.

import java.util.concurrent.locks.ReentrantLock;

private final ReentrantLock lock = new ReentrantLock();

void performLockedOperation() {
    lock.lock(); // Získanie zámku
    try {
        // kód chránený zámkom
    } finally {
        lock.unlock(); // uvoľnenie zámku (dôležité v finally)
    }
}

Použitie tried z balíka java.util.concurrent.atomic: Ponúkajú atómové operácie, ktoré sú vykonávané ako celok bez prerušenia inými vláknami. Vhodné pre jednoduché operácie nad primitívnymi typmi a odkazmi.

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger atomicCounter = new AtomicInteger(0);

void incrementAtomicCounter() {
    atomicCounter.incrementAndGet(); // Atómové zvýšenie
}

Použitie bezpečných kolekcií: Kolekcie z balíka java.util.concurrent (napríklad, ConcurrentHashMap, CopyOnWriteArrayList) sú navrhnuté pre bezpečné použitie vo viacvláknovom prostredí bez explicitnej synchronizácie zo strany vývojára.

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); // bezpečná operácia zápisu
}

Použitie ThreadLocal: Umožňuje vytvoriť premennú, ktorá bude mať samostatnú kópiu pre každé vlákno. Týmto spôsobom, každé vlákno pracuje so svojimi vlastnými dátami, čím sa vylúčia závody.

private final ThreadLocal<Integer> threadLocalValue = new ThreadLocal<Integer>() {
    @Override
    protected Integer initialValue() {
        return 0; // počiatočná hodnota pre každé vlákno
    }
};

void processData() {
    int value = threadLocalValue.get();
    value++;
    threadLocalValue.set(value); // nastavenie hodnoty pre aktuálne vlákno
}

Výber metódy závisí od špecifikácie úlohy, potreby blokovania, typu dát a požadovaného výkonu.

Aké spôsoby boja s pretekaním vlákien, okrem použitia kľúčového slova volatile, poznáte?