Is there a way to solve the race condition problem…

Yes, it exists. Main approaches:

Synchronization: Using the synchronized keyword for methods or code blocks, which guarantees that only one thread can execute that code at any given time.
Locks: Applying classes from the java.util.concurrent.locks package, such as ReentrantLock, which provide more flexible control over locking.
Atomic Variables: Using classes from the java.util.concurrent.atomic package, such as AtomicInteger, AtomicLong, which provide atomic operations (read-modify-write) without the need for explicit locking.
Immutable Objects: Creating objects whose state cannot be changed after creation. If multiple threads have references to the same immutable object, they cannot modify it, which prevents data races.
Thread-Safe Collections: Using collections from the java.util.concurrent package, such as ConcurrentHashMap, CopyOnWriteArrayList, which provide safe access from multiple threads.

Example of using synchronized:

// Example of a synchronized method
public class Counter {
    private int count = 0;

    public synchronized void increment() {
        count++;
    }

    public synchronized int getCount() {
        return count;
    }
}

Example of using ReentrantLock:

import java.util.concurrent.locks.ReentrantLock;

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

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

    public int getCount() {
        lock.lock(); // Acquire lock
        try {
            return count;
        } finally {
            lock.unlock(); // Release lock
        }
    }
}

Example of using AtomicInteger:

import java.util.concurrent.atomic.AtomicInteger;

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

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

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

The choice of a specific method depends on the specifics of the task and the required level of performance. Synchronization is simple to use but can cause overhead. Locks offer more flexibility. Atomic variables are often more efficient for simple operations. Using immutable objects and thread-safe collections is also an effective way to avoid data races.

Is there a way to solve the race condition problem?