title: A reproducible example of volatile usage
body: <p>I am look for a reproducible example that can demonstrate how volatile keyword works. I'm looking for something that works "wrong" without variable(s) marked as volatile and works "correctly" with it.</p>
  
  <p>I mean some example that will demonstrate that order of write/read operations during the execution is different from expected when variable is not marked as volatile and is not different when variable is not marked as volatile.</p>
  
  <p>I thought that I got an example but then with help from others I realized that it just was a piece of wrong multithreading code. <a href="https://stackoverflow.com/questions/6162996/why-volatile-and-memorybarrier-do-not-prevent-operations-reordering">Why volatile and MemoryBarrier do not prevent operations reordering?</a></p>
  
  <p>I've also found a link that demonstrates an effect of volatile on the optimizer but it is different from what I'm looking for. It demonstrates that requests to variable marked as volatile will not be optimized out.<a href="https://stackoverflow.com/questions/133270/how-to-illustrate-usage-of-volatile-keyword-in-c">How to illustrate usage of volatile keyword in C#</a></p>
  
  <p>Here is where I got so far. This code does not show any signs of read/write operation reordering. I'm looking for one that will show.</p>
  
  <pre><code>    using System;
      using System.Threading;
      using System.Threading.Tasks;
      using System.Runtime.CompilerServices;
  
      namespace FlipFlop
      {
          class Program
          {
              //Declaring these variables 
              static byte a;
              static byte b;
  
              //Track a number of iteration that it took to detect operation reordering.
              static long iterations = 0;
  
              static object locker = new object();
  
              //Indicates that operation reordering is not found yet.
              static volatile bool continueTrying = true;
  
              //Indicates that Check method should continue.
              static volatile bool continueChecking = true;
  
              static void Main(string[] args)
              {
                  //Restarting test until able to catch reordering.
                  while (continueTrying)
                  {
                      iterations++;
                      a = 0;
                      b = 0;
                      var checker = new Task(Check);
                      var writter = new Task(Write);
                      lock (locker)
                      {
                          continueChecking = true;
                          checker.Start();
  
                      }
                      writter.Start();
                      checker.Wait();
                      writter.Wait();
                  }
                  Console.ReadKey();
              }
  
              static void Write()
              {
                  //Writing is locked until Main will start Check() method.
                  lock (locker)
                  {
                      WriteInOneDirection();
                      WriteInOtherDirection();
  
                      //Stops spinning in the Check method.
                      continueChecking = false;
                  }
              }
  
              [MethodImpl(MethodImplOptions.NoInlining)]
              static void WriteInOneDirection(){
                  a = 1;
                  b = 10;
              }
  
              [MethodImpl(MethodImplOptions.NoInlining)]
              static void WriteInOtherDirection()
              {
                  b = 20;
                  a = 2;
              }
  
              static void Check()
              {
                  //Spins until finds operation reordering or stopped by Write method.
                  while (continueChecking)
                  {
                      int tempA = a;
                      int tempB = b;
  
                      if (tempB == 10 &amp;&amp; tempA == 2)
                      {
                          continueTrying = false;
                          Console.WriteLine("Caught when a = {0} and b = {1}", tempA, tempB);
                          Console.WriteLine("In " + iterations + " iterations.");
                          break;
                      }
                  }
              }
          }
      }
  </code></pre>
  
  <p>Edit:</p>
  
  <p>As I understand an optimization that causes reordering can come from JITer or from hardware itself. I can rephrase my question. Does JITer or x86 CPUs reorder read/write operations AND is there a way to demonstrate it in C# if they do?</p>