What exactly can go wrong if we do not take care of synchronization? What is a Race Condition?

If synchronization is not taken care of in a multithreaded application, the following problems can occur:

• Race Condition — a situation where multiple threads access a shared resource (e.g., a variable or data structure) simultaneously, and at least one of them modifies this resource. As a result, the final state becomes unpredictable and depends on the order of thread execution.

• Data integrity violations — for example, when incrementing a counter without synchronization, two threads may read the same value, increase it, and write it back, resulting in the counter increasing by only 1 instead of 2.

• Unpredictable behavior and bugs that are difficult to catch and reproduce.

Race Condition — a classic problem in multithreading where the program's outcome depends on the order in which operations are performed across different threads. To avoid race conditions, synchronization mechanisms are used: locks (synchronized, ReentrantLock in Java), atomic operations, volatile variables, and others.

Example of a race condition in Java:

class Counter {
    private int count = 0;

    public void increment() {
        count = count + 1; // non-atomic operation
    }

    public int getCount() {
        return count;
    }
}

// If multiple threads call increment() simultaneously, the final value of count may be less than expected.

To fix this, you need to synchronize the increment() method or use AtomicInteger.