Marking a member function volatile is like marking it const; it means that the receiver object is treated as though it were declared as a volatile T*. Consequentially, any reference to x or y will be treated as a volatile read in the member function. Moreover, a volatile object can only call volatile member functions. … Read more
There’s a good talk by the C++ committee language evolution chair on why. Brief summary, the places that volatile is being removed from didn’t have any well defined meaning in the standard and just caused confusion. Motivating (Ambiguous) Examples Volatile bit Fields should be specified by your hardware manual and/or compiler. Is += a single/atomic … Read more
The main difference between AtomicBoolean and volatile from a practical point of view is that the compare-and-set operation isn’t atomic with volatile variables. volatile boolean b; void foo() { if( b ) { //Here another thread might have already changed the value of b to false b = false; } } But seeing as all … Read more
No, you will never get a NPE. This is because volatile also has the memory-effect of introducing a happens-before relationship. In other words, it will prevent reordering of a = one; b = two; The statements above, will not be re-ordered, and all threads will observe value one for a if b already has value … Read more
Update: For anyone interested this bug has been addressed and fixed for Java 7u6 build b14. You can see the bug report/fixes here Report Changeset Buglist Original Answer When thinking in terms of memory visibility/order you would need to think about its happens-before relationship. The important pre condition for b != 0 is for a … Read more
I’m no expert, but cppreference.com has what appears to me to be some pretty good information on volatile. Here’s the gist of it: Every access (both read and write) made through an lvalue expression of volatile-qualified type is considered an observable side effect for the purpose of optimization and is evaluated strictly according to the … Read more
Declaring an array volatile does not give volatile access to its fields. You’re declaring the reference itself volatile, not its elements. In other words, you’re declaring a volatile set of elements, not a set of volatile elements. The solution here is to use AtomicIntegerArray in case you want to use integers. Another way (but kinda … 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
Volatile –> Guarantees visibility and NOT atomicity Synchronization (Locking) –> Guarantees visibility and atomicity (if done properly) Volatile is not a substitute for synchronization Use volatile only when you are updating the reference and not performing some other operations on it. Example: volatile int i = 0; public void incrementI(){ i++; } will not be … Read more
Consider this example: int i = 5; System.out.println(i); The compiler may optimize this to just print 5, like this: System.out.println(5); However, if there is another thread which can change i, this is the wrong behaviour. If another thread changes i to be 6, the optimized version will still print 5. The volatile keyword prevents such … Read more