Memory Consistency Errors – Concurrency: Part I
Memory Consistency Errors
In a multithreaded application, there is a potential danger that changes made by one thread to shared data might not be visible to the other threads, resulting in inconsistent views of the shared data. When this happens, it is known as a memory consistency error.
Causes of memory consistency errors are too complex to go into here. The following simple example gives an idea of how they can manifest. Two threads have access to a shared counter.
int counter = 0;
// Thread A // Thread B
… …
counter = 1; …
System.out.println(“Thread A:” + counter); System.out.println(“Thread B:” + counter);
… …
Thread A set the counter value to 1 and prints it value. We can safely assume that the value printed would be 1—that is, the value in the counter set by the preceding assignment statement. However, if the print statement is executed by thread B, there is no guarantee that the change in the counter value in thread A will be visible to thread B—it might print 0 or 1—unless it can be established that a change of value in thread A occurred before being printed in thread B.
Happens-Before Relationship
The happens-before relationship helps to combat memory consistency errors. It is important in guaranteeing that one action is ordered before another in a multithreaded runtime environment. More importantly, the first action is visible to the second one, meaning that the results of the first action are evident to the second action. The relationship is transitive: If action A happens-before action B, and action B happens-before action C, then action A happens-before action C.
Little is guaranteed in a multithreaded environment, and therefore, the happens-before relationship is important in ascertaining certain properties about multi-threaded applications. Here are some important rules pertaining to multithreaded applications in Java:
- Object lock rule: An unlock action on a monitor happens-before every subsequent lock action on that monitor.
- Volatile field rule: A write to a volatile field happens-before every subsequent read of that field (§23.4, p. 1453).
- Thread start rule: A call to the Thread.start() method on a thread happens-before any actions in the started thread.
- Thread termination rule: All actions in a thread happen-before any other thread can detect that the thread has terminated, either by successfully returning from a Thread.join() method call or by a Thread.isAlive() method call returning false on that thread.
- Thread interruption rule: A thread calling the Thread.interrupt() method on another thread happens-before the interrupted thread detects the interrupt, either by having an InterruptedException thrown, or by invoking the Thread .isInterrupted() or the Thread.interrupted() method on itself.
