Kādus cīņas veidus ar pavedienu sacensībām, izņemot…

Ir vairākas galvenās pieejas pavedienu sinhronizācijai un sacensības nosacījumu novēršanai Android platformā, papildus volatile.

Izmantojot synchronized: Bloķē piekļuvi kodam vai metodēm citiem pavedieniem līdz pašreizējais pavediens pabeidz darbu.

// Sinhronizēta metode
synchronized void incrementCounter() {
    counter++;
}

// Sinhronizēta bloka
void updateData() {
    synchronized (this) { // vai cits monitor objekts
        // kods, kas prasa sinhronizāciju
    }
}

Izmantojot java.util.concurrent.locks paketi: Piedāvā elastīgākus bloķēšanas mehānismus nekā synchronized.

import java.util.concurrent.locks.ReentrantLock;

private final ReentrantLock lock = new ReentrantLock();

void performLockedOperation() {
    lock.lock(); // Bloķēšanas iegūšana
    try {
        // kods, kas aizsargāts ar bloķi
    } finally {
        lock.unlock(); // Bloķēšanas atbrīvošana
    }
}

Izmantojot java.util.concurrent.atomic paketi: Piedāvā atomiskas operācijas, kas tiek veiktas kā vienība bez pārtraukšanas citiem pavedieniem.

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger atomicCounter = new AtomicInteger(0);

void incrementAtomicCounter() {
    atomicCounter.incrementAndGet(); // Atomiska palielināšana
}

Izmantojot drošas kolekcijas: Kolekcijas no java.util.concurrent paketes, piemēram, ConcurrentHashMap, CopyOnWriteArrayList, ir izstrādātas drošai lietošanai daudzpavedienu vidē bez skaidras sinhronizācijas no izstrādātāja puses.

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); // droša rakstīšanas operācija
}

Izmantojot ThreadLocal: Tas ļauj izveidot mainīgo, kurai katram pavedienam ir atsevišķa kopija. Tādējādi katrs pavediens strādā ar saviem datiem, novēršot sacensības.

private final ThreadLocal<Integer> threadLocalValue = new ThreadLocal<Integer>() {
    @Override
    protected Integer initialValue() {
        return 0; // sākotnējā vērtība katram pavedienam
    }
};

void processData() {
    int value = threadLocalValue.get();
    value++;
    threadLocalValue.set(value); // iestatīt vērtību pašreizējam pavedienam
}

Izvēle ir atkarīga no uzdevuma specifikas, nepieciešamības bloķēt, datu tipa un prasītās veiktspējas.

Kādus cīņas veidus ar pavedienu sacensībām, izņemot volatile atslēgvārda izmantošanu, jūs zināt?