memory-visibility

I've looked at this answer , and it states how: Under the new memory model, when thread A writes to a volatile variable V, and thread B reads from V, any variable values that were visible to A at the time that V was written are guaranteed now to be visible to B. Therefore, given the example: public class Main { static int value = -1; static volatile boolean read; public static void main(String[] args) { Thread a = new Thread(() -> { value = 1; read = true; }); Thread b = new Thread(() -> { while (!read); System.out.println("Value: " + value); }); a.start(); b.start(); } } Is the change to

A sensitive operation in my lab today went completely wrong. An actuator on an electron microscope went over its boundary, and after a chain of events I lost $12 million of equipment. I've narrowed down over 40K lines in the faulty module to this: import java.util.*; class A { static Point currentPos = new Point(1,2); static class Point { int x; int y; Point(int x, int y) { this.x = x; this.y = y; } } public static void main(String[] args) { new Thread() { void f(Point p) { synchronized(this) {} if (p.x+1 != p.y) { System.out.println(p.x+" "+p.y); System.exit(1); } } @Override public void run(

Let's see this simple Java program: import java.util.*; class A { static B b; static class B { int x; B(int x) { this.x = x; } } public static void main(String[] args) { new Thread() { void f(B q) { int x = q.x; if (x != 1) { System.out.println(x); System.exit(1); } } @Override public void run() { while (b == null); while (true) f(b); } }.start(); for (int x = 0;;x++) b = new B(Math.max(x%2,1)); } } Main thread The main thread creates an instance of B with x set to 1, then writes that instance to the static field A.b . It repeats this action forever. Polling thread The spawned thread polls

My teacher in an upper level Java class on threading said something that I wasn't sure of. He stated that the following code would not necessarily update the ready variable. According to him, the two threads don't necessarily share the static variable, specifically in the case when each thread (main thread versus ReaderThread ) is running on its own processor and therefore doesn't share the same registers/cache/etc and one CPU won't update the other. Essentially, he said it is possible that ready is updated in the main thread, but NOT in the ReaderThread , so that ReaderThread will loop