Impress your colleagues with your knowledge about…the volatile keyword

Sometimes when working with C# you discover some hidden gems. Some of them very useful, other ones a little bit harder to find a good way to benefit from their functionality. One of those hidden gems that I discovered some time ago is the volatile keyword.

The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Fields that are declared volatile are not subject to compiler optimizations that assume access by a single thread. This ensures that the most up-to-date value is present in the field at all times.

The volatile modifier is usually used for a field that is accessed by multiple threads without using the lock statement to serialize access.

The following example demonstrates how an auxiliary or worker thread can be created and used to perform processing in parallel with that of the primary thread.

 

   1:  using System;

   2:  using System.Threading;

   3:   

   4:  public class Worker

   5:  {

   6:      // This method is called when the thread is started.

   7:      public void DoWork()

   8:      {

   9:          while (!_shouldStop)

  10:          {

  11:              Console.WriteLine("Worker thread: working...");

  12:          }

  13:          Console.WriteLine("Worker thread: terminating gracefully.");

  14:      }

  15:      public void RequestStop()

  16:      {

  17:          _shouldStop = true;

  18:      }

  19:      // Keyword volatile is used as a hint to the compiler that this data

  20:      // member is accessed by multiple threads.

  21:      private volatile bool _shouldStop;

  22:  }

  23:   

  24:  public class WorkerThreadExample

  25:  {

  26:      static void Main()

  27:      {

  28:          // Create the worker thread object. This does not start the thread.

  29:          Worker workerObject = new Worker();

  30:          Thread workerThread = new Thread(workerObject.DoWork);

  31:   

  32:          // Start the worker thread.

  33:          workerThread.Start();

  34:          Console.WriteLine("Main thread: starting worker thread...");

  35:   

  36:          // Loop until the worker thread activates.

  37:          while (!workerThread.IsAlive) ;

  38:   

  39:          // Put the main thread to sleep for 1 millisecond to

  40:          // allow the worker thread to do some work.

  41:          Thread.Sleep(1);

  42:   

  43:          // Request that the worker thread stop itself.

  44:          workerObject.RequestStop();

  45:   

  46:          // Use the Thread.Join method to block the current thread 

  47:          // until the object's thread terminates.

  48:          workerThread.Join();

  49:          Console.WriteLine("Main thread: worker thread has terminated.");

  50:      }

  51:      // Sample output:

  52:      // Main thread: starting worker thread...

  53:      // Worker thread: working...

  54:      // Worker thread: working...

  55:      // Worker thread: working...

  56:      // Worker thread: working...

  57:      // Worker thread: working...

  58:      // Worker thread: working...

  59:      // Worker thread: terminating gracefully.

  60:      // Main thread: worker thread has terminated.

  61:  }

  62:   

  63:   

For more information: http://igoro.com/archive/volatile-keyword-in-c-memory-model-explained/