When multiple threads try to access and modify a shared resource concurrently, leading to unpredictable outcomes based on execution timing, what specific concurrency issue arises?

The specific concurrency issue that arises when multiple threads try to access and modify a shared resource concurrently, leading to unpredictable outcomes based on execution timing, is a Race Condition. A Race Condition occurs when the correctness of a program's output depends on the specific sequence or timing of operations performed by multiple concurrent threads on a shared resource. The outcome becomes non-deterministic, meaning it can vary each time the program runs, leading to potentially incorrect results.

To understand this, a thread is an independent path of execution within a program, capable of running concurrently with other threads. A shared resource refers to any data, memory location, file, or hardware device that can be accessed and potentially modified by multiple threads. Concurrent access and modification means that multiple threads are attempting to read from or write to this shared resource at overlapping times. The problem arises because the operations of reading, modifying, and writing to a shared resource are often not atomic, meaning they can be interrupted by other threads.

For example, consider two threads, Thread A and Thread B, both trying to increment a shared integer variable `counter` that starts at 0.
1. Thread A reads the value of `counter` (which is 0).
2. The operating system's scheduler might pause Thread A and allow Thread B to run.
3. Thread B reads the value of `counter` (which is still 0, because Thread A hasn't written its update yet).
4. Thread B increments its local copy to 1 and writes this new value (1) back to `counter`.
5. The scheduler resumes Thread A.
6. Thread A, still holding the original value 0, increments its local copy to 1 and writes this new value (1) back to `counter`.

In this scenario, after both threads have supposedly incremented the counter, its final value is 1 instead of the expected 2. This unpredictable outcome is a direct result of the specific interleaving of operations dictated by the execution timing. Race conditions are typically resolved using synchronization mechanisms like locks or mutexes to ensure that only one thread can access the critical section (the code modifying the shared resource) at any given time, thereby making the operation atomic and guaranteeing correct results.