Why do race conditions occur and what methods exist…

Race conditions occur when multiple threads access shared mutable data simultaneously, and the outcome depends on the order of execution. This happens because the operating system can switch between threads at any moment, interrupting their execution.

Ways to combat:

Synchronization: Using synchronization primitives to ensure exclusive access to shared resources.

synchronized keyword: Applied to methods or code blocks. It locks access to an object or class for other threads until the current thread finishes executing the synchronized block/method.

// Synchronizing a method
public synchronized void updateData(int newValue) {
    // ... updating shared data
}

// Synchronizing a code block
public void processData() {
    synchronized (this) { // Or any other monitor object
        // ... access to shared data
    }
}

Locks (Lock): Provide more flexible control over synchronization compared to synchronized.

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

private final Lock dataLock = new ReentrantLock();

public void safeUpdateData(int newValue) {
    dataLock.lock(); // Acquire lock
    try {
        // ... update shared data
    } finally {
        dataLock.unlock(); // Release lock
    }
}

Atomic variables (Atomic...): Offer thread-safe operations on primitive types without explicit locking. Used for simple operations (increment, compare-and-swap).

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger counter = new AtomicInteger(0);

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

Thread-safe collections: Use special collections from the java.util.concurrent package (e.g., ConcurrentHashMap, CopyOnWriteArrayList) designed for concurrent access.
```
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

private final Map<String, Integer> safeMap = new ConcurrentHashMap<>();
```
Immutable objects: If data does not change after creation, it can be safely accessed from multiple threads without synchronization.

Thread-local variables (ThreadLocal): Each thread gets its own copy of a variable, preventing access conflicts.

private final ThreadLocal<Integer> threadId = new ThreadLocal<>();

public void setThreadId() {
    threadId.set(Thread.currentThread().getId());
}

public int getThreadId() {
    return threadId.get();
}

Proper architecture design: Minimizing shared mutable data and using asynchronous approaches or message passing between threads can reduce race conditions.

Why do race conditions occur and what methods exist to fight them?