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
You are not doing anything wrong. According to the documentation: A volatile field should not normally be passed using a ref or out parameter, since it will not be treated as volatile within the scope of the function. There are exceptions to this, such as when calling an interlocked API.
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
A couple of things, first will be flushed to memory – that’s pretty erroneous. It’s almost never a flush to main memory – it usually drains the StoreBuffer to L1 and it’s up to the cache coherency protocol to sync the data between all caches, but if it’s easier for you to understand this concept … Read more
I’ll address the last question first. Microsoft’s .NET implementation has release semantics on writes1. It’s not C# per se, so the same program, no matter the language, in a different implementation can have weak non-volatile writes. The visibility of side-effects is regarding multiple threads. Forget about CPUs, cores and caches. Imagine, instead, that each thread … Read more
The short answer is: Because the standard says you won’t. The C++ Standard 12.8/9 (Draft N3242) tells: The implicitly-declared copy constructor for a class X will have the form X::X(const X&) if each direct or virtual base class B of X has a copy constructor whose first parameter is of type const B& or const … Read more
The statement “the value can be changed by means outside of this code” basically means that another program or hardware can update that variable. This is totally possible. One way of thinking of this is by relating this concept to a file that is shared among multiple programs. A file can be opened, written, and … 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
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 Interlocked.Exchange uses a processor instruction that guarantees an atomic operation. The Volatile.Write does the same but it also includes a memory barrier operation. I think Microsoft added Volatile.Write on DotNet 4.5 due to support of ARM processors on Windows 8. Intel and ARM processors differs on memory operation reordering. On Intel, you have a … Read more