Consider a simple class called
Counter
class Counter { private int c = 0; public void increment() { c++; } public void decrement() { c--; } public int value() { return c; } }Counter
is designed so that each invocation ofincrement
will add 1 toc
, and each invocation ofdecrement
will subtract 1 fromc
. However, if aCounter
object is referenced from multiple threads, interference between threads may prevent this from happening as expected.Interference happens when two operations, running in different threads, but acting on the same data, interleave. This means that the two operations consist of multiple steps, and the sequences of steps overlap.
It might not seem possible for operations on instances of
Counter
to interleave, since both operations onc
are single, simple statements. However, even simple statements can translate to multiple steps by the virtual machine. We won't examine the specific steps the virtual machine takes — it is enough to know that the single expressionc++
can be decomposed into three steps:The expression
- Retrieve the current value of
c
.- Increment the retrieved value by 1.
- Store the incremented value back in
c
.c--
can be decomposed the same way, except that the second step decrements instead of increments.Suppose Thread A invokes
increment
at about the same time Thread B invokesdecrement
. If the initial value ofc
is0
, their interleaved actions might follow this sequence:Thread A's result is lost, overwritten by Thread B. This particular interleaving is only one possibility. Under different circumstances it might be Thread B's result that gets lost, or there could be no error at all. Because they are unpredictable, thread interference bugs can be difficult to detect and fix.
- Thread A: Retrieve c.
- Thread B: Retrieve c.
- Thread A: Increment retrieved value; result is 1.
- Thread B: Decrement retrieved value; result is -1.
- Thread A: Store result in c; c is now 1.
- Thread B: Store result in c; c is now -1.