Consider this code, int some_int = 100; while(some_int == 100) { //your code } When this program gets compiled, the compiler may optimize this code, if it finds that the program never ever makes any attempt to change the value of some_int, so it may be tempted to optimize the while loop by changing it … Read more
I believe that Atomic* actually gives both atomicity and volatility. So when you call (say) AtomicInteger.get(), you’re guaranteed to get the latest value. This is documented in the java.util.concurrent.atomic package documentation: The memory effects for accesses and updates of atomics generally follow the rules for volatiles, as stated in section 17.4 of The Java™ Language … Read more
Since x and y have been declared as volatile, the programmer expects that they will be changed from outside the program. In that case, your code will remain in the loop while(x>y); and will return the value x-y after the values are changed from outside such that x <= y. The exact reason why this … Read more
You don’t need a synchronized variable, but rather an atomic variable. Luckily, you can just use std::atomic<bool>. The key issue is that if more than one thread accesses the same memory simultaneously, then unless the access is atomic, your entire program ceases to be in a well-defined state. Perhaps you’re lucky with a bool, which … Read more
Short of reading the memory model specification, I recommend you read http://jeremymanson.blogspot.com/2008/11/what-volatile-means-in-java.html. It’s written by one of the Java Memory Model authors and should answer your question. Thinking of memory reads and writes in terms of the happens-before clause is also helpful; the JMM for Java 5 onwards adds happens-before semantics to volatile. Specifically, when … Read more
volatile is a field modifier, while synchronized modifies code blocks and methods. So we can specify three variations of a simple accessor using those two keywords: int i1; int geti1() {return i1;} volatile int i2; int geti2() {return i2;} int i3; synchronized int geti3() {return i3;} geti1() accesses the value currently stored in i1 in … Read more
I’ve used volatile where I’m not sure it is necessary. Let me be very clear on this point: If you are not 100% clear on what volatile means in C# then do not use it. It is a sharp tool that is meant to be used by experts only. If you cannot describe what all … Read more
Use AtomicIntegerArray or AtomicLongArray or AtomicReferenceArray The AtomicIntegerArray class implements an int array whose individual fields can be accessed with volatile semantics, via the class’s get() and set() methods. Calling arr.set(x, y) from one thread will then guarantee that another thread calling arr.get(x) will read the value y (until another value is read to position … Read more
i = 1 always happens-before v = 2 True. By JLS section 17.4.5, If x and y are actions of the same thread and x comes before y in program order, then hb(x, y). v = 2 happens-before vDst = v in JMM only if it’s actually happens before in time i = 1 happens-before … Read more
Firmware developer here. This is a standard problem in embedded programming, and one that trips up many (even very experienced) developers. My assumption is that you are attempting to access a hardware register, and that register value can change over time (be it interrupt status, timer, GPIO indications, etc.). The volatile keyword is only part … Read more