What ways do you know to combat race conditions…

There are several main approaches to thread synchronization and preventing race conditions 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 the 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 the lock
    } finally {
        lock.unlock(); // Release lock (important in finally)
    }
}

Using classes from the 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 the java.util.concurrent package (e.g., ConcurrentHashMap, CopyOnWriteArrayList) are designed for safe use in multithreaded environments without explicit synchronization by 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 copy of 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 the current thread
}

The choice of method depends on the specifics of the task, the need for locking, data type, and performance requirements.

What ways do you know to combat race conditions besides using the volatile keyword?