Java.Multithreading.What is a race condition?

🔥 Understanding race conditions is essential for mastering concurrent programming — and avoiding some very sneaky bugs.

---

🧠 What is a Race Condition?

A race condition occurs when two or more threads access shared data at the same time, and the final outcome depends on the timing or interleaving of their execution.

In other words:

Threads are “racing” to access or modify data, and whoever wins the race changes the result — possibly incorrectly.

---

🚨 Why It’s a Problem

• Threads are not synchronized.
• Operations that look atomic in code (like x++) are not actually atomic.
• Result is unpredictable, often non-deterministic bugs.

🧪 Simple Example (Broken Counter)

class Counter {
    int count = 0;

    void increment() {
        count++; // Not atomic!
    }
}

If 3 threads call increment() at the same time, you’d expect count = 3, but it could be 2 or even 1.

Why? Because count++ is actually:

1. Read count
2. Add 1
3. Write back

If two threads do this at once, they might read the same value and overwrite each other’s result — 🧨 race condition!

⛑️ Fixing Race Conditions

Fix	How it helps
synchronized	Only one thread enters at a time
AtomicInteger / CAS	Uses atomic operations (lock-free)
Locks (ReentrantLock)	Advanced, flexible locking

Or use:

AtomicInteger count = new AtomicInteger(0);
count.incrementAndGet(); // thread-safe

🧭 How to Detect Race Conditions?

• Unpredictable behavior
• Inconsistent results on repeated runs
• Use tools:
  • 🔍 FindBugs / SpotBugs
  • 🔬 Thread sanitizers (e.g., in IntelliJ, VisualVM, or with tooling like Java Flight Recorder)

🎯 Real-World Analogy

Imagine two people trying to write on the same whiteboard at the same time without coordinating:

• One writes “42”
• Another writes “43”
• The result is scribbled nonsense — or one person’s message overwrites the other’s.

---

✅ Summary

Concept	Race Condition
What it is	Threads accessing shared data unsafely
Cause	Lack of synchronization
Result	Unpredictable, inconsistent outcomes
Fix	Use synchronized, Atomic*, or locks