Java Reference
In-Depth Information
reads or updates of any other field or element. In particular, two threads that update ad-
jacent elements of a byte array separately must not interfere or interact and do not need
synchronization to ensure sequential consistency.
Some processors do not provide the ability to write to a single byte. It would be illegal to
implement byte array updates on such a processor by simply reading an entire word, updat-
ing the appropriate byte, and then writing the entire word back to memory. This problem
is sometimes known as
word tearing
, and on processors that cannot easily update a single
byte in isolation some other approach will be required.
Example 17.6-1. Detection of Word Tearing
The following program is a test case to detect word tearing:
public class WordTearing extends Thread {
static final int LENGTH = 8;
static final int ITERS = 1000000;
static byte[] counts = new byte[LENGTH];
static Thread[] threads = new Thread[LENGTH];
final int id;
WordTearing(int i) {
id = i;
}
public void run() {
byte v = 0;
for (int i = 0; i < ITERS; i++) {
byte v2 = counts[id];
if (v != v2) {
System.err.println("Word-Tearing found: " +
"counts[" + id + "] = "+ v2 +
", should be " + v);
return;
}
v++;
counts[id] = v;
}
}
public static void main(String[] args) {
for (int i = 0; i < LENGTH; ++i)
(threads[i] = new WordTearing(i)).start();
}
}
This makes the point that bytes must not be overwritten by writes to adjacent bytes.
