Difference between Interlocked.Exchange and Volatile.Write?

by

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 guarantee that memory access operations will be done in the same order they are issued, or at least that a write operation won’t be reordered.

From Intel® 64 and IA-32 Architectures Software Developer’s Manual, Chapter 8:

8.2.2 Memory Ordering in P6 and More Recent Processor Families The Intel Core 2 Duo, Intel Atom, Intel Core Duo, Pentium 4, and P6 family
processors also use a processor-ordered memory-ordering model that can
be further defined as “write ordered with store-buffer forwarding.”
This model can be characterized as follows.

On ARM you don’t have this kind of guarantee, so a memory barrier is required. An ARM blog explaining this can be found here: http://blogs.arm.com/software-enablement/594-memory-access-ordering-part-3-memory-access-ordering-in-the-arm-architecture/

In your example, as the operation with double is not guaranteed to be atomic, I would recommend a lock to access it. Remember that you have to use the lock on both parts of your code, when reading and setting the value.

A more complete example would be better to answer your question, as it is not clear what happens after these values are set. For a vector, if you have more readers than writers, consider the use of a ReaderWriterLockSlim object: http://msdn.microsoft.com/en-us/library/system.threading.readerwriterlockslim.aspx

The number of threads and the frequency of read/writes can change dramatically your locking strategy.

More Related Contents:

  1. Volatile vs. Interlocked vs. lock
  2. Collection was modified; enumeration operation may not execute
  3. What’s the best way of implementing a thread-safe Dictionary?
  4. System.Lazy with different thread-safety mode
  5. Why we need Thread.MemoryBarrier()?
  6. Thread-safe List property
  7. Why do I need a memory barrier?
  8. Entity Framework Thread Safety
  9. Thread safety of a Dictionary with multiple concurrent readers and no writers
  10. Is a reference assignment threadsafe?
  11. What is the “volatile” keyword used for?
  12. Do I need to lock or mark as volatile when accessing a simple boolean flag in C#?
  13. Async threadsafe Get from MemoryCache
  14. thread with multiple parameters
  15. Event handlers not thread safe? [duplicate]
  16. What Makes a Method Thread-safe? What are the rules?
  17. Are you there, asynchronously written value?
  18. Should Interlocked.CompareExchange also a volatile variable?
  19. Reading an int that’s updated by Interlocked on other threads
  20. Is this use of Parallel.ForEach() thread safe?
  21. System.InvalidOperationException: Collection was modified
  22. How to correctly read an Interlocked.Increment’ed int field?
  23. ConcurrentDictionary Pitfall – Are delegates factories from GetOrAdd and AddOrUpdate synchronized?
  24. Thread safety on readonly static field initialisation
  25. Is Stopwatch.ElapsedTicks threadsafe?
  26. C# volatile variable: Memory fences VS. caching
  27. C# and thread-safety of a bool
  28. Is it ok to await the same task from multiple threads – is await thread safe?
  29. Singleton double-check concurrency issue
  30. Writing to file in a thread safe manner

Leave a Comment