What are other ways to deal with race conditions…

Synchronization (synchronized): The synchronized keyword ensures atomic execution of code blocks or methods. Only one thread can execute a synchronized block/method for a given object at any time.

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

// Synchronized block
public void updateValue(int newValue) {
    synchronized (this) {
        value = newValue;
    }
}

Locks: A more flexible mechanism compared to synchronized. Allows explicit lock management using lock() and unlock() methods. Typically uses implementations of the Lock interface from java.util.concurrent.locks, such as ReentrantLock.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class SafeCounter {
    private int count = 0;
    private final Lock lock = new ReentrantLock();

    public void increment() {
        lock.lock(); // Acquire lock
        try {
            count++;
        } finally {
            lock.unlock(); // Release lock
        }
    }
}

Atomic Variables: Classes from java.util.concurrent.atomic package (e.g., AtomicInteger, AtomicLong, AtomicReference). They provide atomic operations on single variables using low-level CPU instructions (Compare-And-Swap - CAS), often more efficient than locking.

import java.util.concurrent.atomic.AtomicInteger;

public class AtomicCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // Atomic increment
    }
}

Concurrent Collections: Thread-safe collections from java.util.concurrent package (e.g., ConcurrentHashMap, CopyOnWriteArrayList). Designed to support concurrent access without explicit synchronization, often using internal locking mechanisms or optimized algorithms.

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

public class SharedCache {
    private final Map<String, String> cache = new ConcurrentHashMap<>();

    public void put(String key, String value) {
        cache.put(key, value);
    }

    public String get(String key) {
        return cache.get(key);
    }
}

Immutable Objects: Using immutable objects eliminates the need for synchronization since their state cannot be changed after creation. Immutable objects are inherently thread-safe.

public final class ImmutablePoint {
    private final int x;
    private final int y;

    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() { return x; }
    public int getY() { return y; }
}

ThreadLocal Variables: Provide a way to store variables that are accessible only to the current thread. Each thread has its own independent copy of the variable, eliminating concurrency issues as data is not shared between threads.

import java.lang.ThreadLocal;

public class ThreadSpecificData {
    private static final ThreadLocal<Integer> threadId = ThreadLocal.withInitial(() -> (int) Thread.currentThread().getId());

    public static Integer getThreadId() {
        return threadId.get();
    }
}

Dispatchers / Executors: In Android development, dispatchers (e.g., Dispatchers in Kotlin Coroutines) or executors (e.g., ExecutorService in Java) are often used to manage task execution on specific threads or thread pools. Proper use of these mechanisms can isolate state changes on one thread, avoiding race conditions.

// Example with Kotlin Coroutines
import kotlinx.coroutines.*

fun updateUI() {
    GlobalScope.launch(Dispatchers.Main) {
        // Code that modifies UI runs on the main thread
    }
}

// Example with ExecutorService
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class BackgroundTask {
    private final ExecutorService executor = Executors.newSingleThreadExecutor();

    public void performOperation() {
        executor.submit(() -> {
            // Costly operation runs on a separate thread
        });
    }
}

What are other ways to deal with race conditions besides using the volatile keyword?