memory-visibility | 易学教程

jvm reordering/visibility effect test

阅读更多关于 jvm reordering/visibility effect test

问题 While writing some java article I'm trying to reproduce re-ordering in case of unsynchronized object costruction in multithreaded environment. The case when a heavy object is constructed w/o synchonization/volatiles/finals and other threads get access to it right after constructor call. Here is the code I try: public class ReorderingTest { static SomeObject<JPanel>[] sharedArray = new SomeObject[100]; public static void main(String[] args) { for (int i = 0; i < 100; i++) { String name =

Why does this simple threaded program get stuck?

阅读更多关于 Why does this simple threaded program get stuck?

问题 Take a look at this simple Java program: import java.lang.*; class A { static boolean done; public static void main(String args[]) { done = false; new Thread() { public void run() { try { Thread.sleep(1000); // dummy work load } catch (Exception e) { done = true; } done = true; } }.start(); while (!done); System.out.println("bye"); } } On one machine, it prints "bye" and exits right away, while on another machine, it doesn't print anything and sits there forever. Why? 回答1: This is because

Why does this simple threaded program get stuck?

阅读更多关于 Why does this simple threaded program get stuck?

Does atomic variables guarantee memory visibility?

阅读更多关于 Does atomic variables guarantee memory visibility?

问题 Small question about memory visibility. CodeSample1: class CustomLock { private boolean locked = false; public boolean lock() { if(!locked) { locked = true; return true; } return false; } } This code is prone to bugs in a multi-threaded environment, first because of the "if-then-act" which is not atomic, and second because of potential memory visibility issues where for example threadA sets the field to true, but threadB that later wishes to read the field's value might not see that, and

Atomic operation propagation/visibility (atomic load vs atomic RMW load)

阅读更多关于 Atomic operation propagation/visibility (atomic load vs atomic RMW load)

问题 Context I am writing a thread-safe protothread/coroutine library in C++, and I am using atomics to make task switching lock-free. I want it to be as performant as possible. I have a general understanding of atomics and lock-free programming, but I do not have enough expertise to optimise my code. I did a lot of researching, but it was hard to find answers to my specific problem: What is the propagation delay/visiblity for different atomic operations under different memory orders? Current

Uninitialized object leaked to another thread despite no code explicitly leaking it?

阅读更多关于 Uninitialized object leaked to another thread despite no code explicitly leaking it?

问题 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

Does a volatile reference really guarantee that the inner state of the object is visible to other threads?

阅读更多关于 Does a volatile reference really guarantee that the inner state of the object is visible to other threads?

问题 While reading "Java Concurrency in Practice", I came across the following - To publish an object safely, both the reference to the object and the object's state must be made visible to other threads at the same time. A properly constructed object can be safely published by: Initializing an object reference from a static initializer; Storing a reference to it into a volatile field or AtomicReference; Storing a reference to it into a final field of a properly constructed object; or Storing a

Why does this simple threaded program get stuck?

阅读更多关于 Why does this simple threaded program get stuck?

Take a look at this simple Java program: import java.lang.*; class A { static boolean done; public static void main(String args[]) { done = false; new Thread() { public void run() { try { Thread.sleep(1000); // dummy work load } catch (Exception e) { done = true; } done = true; } }.start(); while (!done); System.out.println("bye"); } } On one machine, it prints "bye" and exits right away, while on another machine, it doesn't print anything and sits there forever. Why? This is because your boolean is not volatile , therefore Thread s are allowed to cache copies of it and never update them. I

jvm reordering/visibility effect test

阅读更多关于 jvm reordering/visibility effect test

While writing some java article I'm trying to reproduce re-ordering in case of unsynchronized object costruction in multithreaded environment. The case when a heavy object is constructed w/o synchonization/volatiles/finals and other threads get access to it right after constructor call. Here is the code I try: public class ReorderingTest { static SomeObject<JPanel>[] sharedArray = new SomeObject[100]; public static void main(String[] args) { for (int i = 0; i < 100; i++) { String name = "watcher" + i; new Thread(new Watcher(name)).start(); System.out.printf("watcher %s started!%n", name); } }

Atomic operation propagation/visibility (atomic load vs atomic RMW load)

阅读更多关于 Atomic operation propagation/visibility (atomic load vs atomic RMW load)

Context I am writing a thread-safe protothread/coroutine library in C++, and I am using atomics to make task switching lock-free. I want it to be as performant as possible. I have a general understanding of atomics and lock-free programming, but I do not have enough expertise to optimise my code. I did a lot of researching, but it was hard to find answers to my specific problem: What is the propagation delay/visiblity for different atomic operations under different memory orders? Current assumptions I read that changes to memory are propagated from other threads, in such a way that they