Lambda the Ultimate

Daniel Yokomiso.

"State is hell. You need to design systems under the assumption that state is hell. Everything that can be stateless should be stateless." - Ken Arnold

That is, after all, what locking primitives are for. If your code is so performance critical that you don't even want to take the time to do that, what the heck are you doing writing the code in a language designed to target a VM, rather than the real M?

Whether language designs should provide this type of abstraction is a good question. Perhaps it is better to make it clear what is guaranteed by the language and what isn't, rather than just hope programmers not make unwarranted assumptions?

public class Broken {
    final int n;
    Broken() throws Exception {
        new Thread(new Runnable() {
            public void run() {
                try {
                    do {
                        System.out.println("First time: " + n);
                        Thread.sleep(100);
                        System.out.println("Second time: " + n);
                    } while (n != 1000);
                } catch (Exception ignored) {
                }
            }
        }).start();
        Thread.sleep(500);
        this.n = 1000;
    }
    public static void main(String[] args) throws Exception {
        new Broken();
    }
}

Not using real locks, as provided by your system, around access to shared data is only sane if you're trying to roll your own locking system, and it's been my experience that, to a good first approximation, exactly one person per OS/CPU combination should be doing this. There are so many subtle problems that crop up, even in a uniprocessor system, that are insanely difficult to track down that it just isn't worth it. You get weird word-shear write problems, overlaid structs and objects, double-created objects/structs (which often leak, though that at least doesn't happen with a tracing GC system), race issues, double or half data alterations... it's just a mess.

Guaranteed ordering of memory access doesn't help any of that, and providing a guarantee of memory access ordering actually makes it *worse*, since it gives an illusion of correctness with the occasional heisenbug showing up to puzzle the unwary.

I swear, everyone who writes threaded code should be forced to develop the stuff on quad-processor Alpha systems, possibly the most vicious multithreading environment around. (Well, except maybe for 6 and 8 processor Alpha systems) If the stuff runs right there, it'll run right anywhere.