Why do race conditions occur and what methods can be…

Race conditions occur when two or more threads access shared data simultaneously, and at least one of the threads modifies the data. The order of operations in such cases is undefined, which can lead to unpredictable results or data corruption.

Methods to prevent race conditions:

Synchronization: Used to control access to shared resources. Only one thread can enter a synchronized block or method at a time.

public class SharedResource {
    private int count = 0;

    public synchronized void increment() { // Synchronization at method level
        count++;
    }

    public void decrement() {
        synchronized (this) { // Synchronization at block level
            count--;
        }
    }

    public int getCount() {
        return count;
    }
}

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

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

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

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

    public void decrement() {
        lock.lock();
        try {
            count--;
        } finally {
            lock.unlock();
        }
    }

    public int getCount() {
        return count;
    }
}

Atomic Operations: Use special CPU instructions to perform operations on single variables as a whole, without interruption by other threads.

import java.util.concurrent.atomic.AtomicInteger;

public class SharedResourceAtomic {
    private AtomicInteger count = new AtomicInteger(0); // Atomic int

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

    public void decrement() {
        count.decrementAndGet(); // Atomic decrement
    }

    public int getCount() {
        return count.get(); // Atomic read
    }
}

Volatile Variables: Ensure visibility of variable changes across all threads. Do not guarantee atomicity of compound operations (e.g., increment).

public class SharedResourceVolatile {
    private volatile boolean flag = false; // Ensures visibility of flag changes

    public void setFlag(boolean value) {
        flag = value;
    }

    public boolean getFlag() {
        return flag;
    }
    // To avoid race conditions when modifying volatile variables,
    // more powerful mechanisms (synchronized, Lock, Atomic) are usually used.
}

Using thread-safe collections: Collections from the java.util.concurrent package (e.g., ConcurrentHashMap, CopyOnWriteArrayList) provide built-in synchronization mechanisms.

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

public class SharedCache {
    private Map<String, String> cache = new ConcurrentHashMap<>(); // Thread-safe map

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

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

Immutable objects: Objects whose state cannot be changed after creation. Accessing them from different threads does not lead to race conditions.

The choice of method depends on the specific situation, required performance, and management complexity.

Why do race conditions occur and what methods can be used to prevent them?