I decided to give Kotlin a shot by just using the “convert java to kotlin” function in IntelliJ. Apparently that set things up wrong. I tried doing the same thing, but after applying the Kotlin Gradle plugin and placing the file in src/kotlin and it all worked. Thanks for the help anyway guys. The code … 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
There are read barriers and write barriers; acquire barriers and release barriers. And more (io vs memory, etc). The barriers are not there to control “latest” value or “freshness” of the values. They are there to control the relative ordering of memory accesses. Write barriers control the order of writes. Because writes to memory are … Read more
To summarize what others have correctly written: C/C++ volatile is for hardware access and interrupts. C++11 atomic<> is for inter-thread communication (e.g., in lock-free code). Those two concepts/uses are orthogonal, but they have overlapping requirements and that is why people have often confused the two. The reason that atomic<> has volatile-qualified functions is the same … Read more
No. Access to volatile objects is considered observable behavior, exactly as I/O, with no particular distinction between locals and globals. The least requirements on a conforming implementation are: Access to volatile objects are evaluated strictly according to the rules of the abstract machine. […] These collectively are referred to as the observable behavior of the … 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
A pointer of the form volatile int* p; is a pointer to an int that the compiler will treat as volatile. This means that the compiler will assume that it is possible for the variable that p is pointing at to have changed even if there is nothing in the source code to suggest that … Read more
I’ve achieved a working example! The main idea received from wiki, but with some changes for C#. The wiki article demonstrates this for static field of C++, it is looks like C# always carefully compile requests to static fields… and i make example with non static one: If you run this example in Release mode … Read more
Rather than explaining what volatile does, allow me to explain when you should use volatile. When inside a signal handler. Because writing to a volatile variable is pretty much the only thing the standard allows you to do from within a signal handler. Since C++11 you can use std::atomic for that purpose, but only if … Read more
Volatile is unnecessary. Well, sort of** volatile is used to create a memory barrier* between reads and writes on the variable. lock, when used, causes memory barriers to be created around the block inside the lock, in addition to limiting access to the block to one thread. Memory barriers make it so each thread reads … Read more