Milliseid võtteid teate niitide võidu võitlemiseks…

There are several main approaches to thread synchronization and race condition prevention in Android, besides volatile.

Using synchronized: Locks access to code or methods for other threads until the current thread finishes.

// Synchronized method
synchronized void incrementCounter() {
    counter++;
}

// Synchronized block
void updateData() {
    synchronized (this) { // or another monitor object
        // code requiring synchronization
    }
}

Using classes from java.util.concurrent.locks package: Provide more flexible locking mechanisms than synchronized.

import java.util.concurrent.locks.ReentrantLock;

private final ReentrantLock lock = new ReentrantLock();

void performLockedOperation() {
    lock.lock(); // Acquire lock
    try {
        // code protected by lock
    } finally {
        lock.unlock(); // Release lock
    }
}

Using classes from java.util.concurrent.atomic package: Provide atomic operations that execute as a whole without interruption by other threads. Suitable for simple operations on primitive types and references.

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger atomicCounter = new AtomicInteger(0);

void incrementAtomicCounter() {
    atomicCounter.incrementAndGet(); // Atomic increment
}

Using thread-safe collections: Collections from java.util.concurrent package (e.g., ConcurrentHashMap, CopyOnWriteArrayList) are designed for safe use in multithreaded environments without explicit synchronization from the developer.

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); // Safe write operation
}

Using ThreadLocal: Allows creating a variable that has a separate copy for each thread. Thus, each thread works with its own data, avoiding race conditions.

private final ThreadLocal<Integer> threadLocalValue = new ThreadLocal<Integer>() {
    @Override
    protected Integer initialValue() {
        return 0; // Initial value for each thread
    }
};

void processData() {
    int value = threadLocalValue.get();
    value++;
    threadLocalValue.set(value); // Set value for current thread
}

The choice of method depends on the specifics of the task, locking needs, data type, and required performance.

Milliseid võtteid teate niitide võidu võitlemiseks, välja arvatud volatile võtmesõna kasutamine?