Skip to main content

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/

Labels:

Popular posts from this blog

Podman– Command execution failed with exit code 125

After updating WSL on one of the developer machines, Podman failed to work. When we took a look through Podman Desktop, we noticed that Podman had stopped running and returned the following error message: Error: Command execution failed with exit code 125 Here are the steps we tried to fix the issue: We started by running podman info to get some extra details on what could be wrong: >podman info OS: windows/amd64 provider: wsl version: 5.3.1 Cannot connect to Podman. Please verify your connection to the Linux system using `podman system connection list`, or try `podman machine init` and `podman machine start` to manage a new Linux VM Error: unable to connect to Podman socket: failed to connect: dial tcp 127.0.0.1:2655: connectex: No connection could be made because the target machine actively refused it. That makes sense as the podman VM was not running. Let’s check the VM: >podman machine list NAME         ...
Read more

Azure DevOps/ GitHub emoji

I’m really bad at remembering emoji’s. So here is cheat sheet with all emoji’s that can be used in tools that support the github emoji markdown markup: All credits go to rcaviers who created this list.
Read more

VS Code Planning mode

After the introduction of Plan mode in Visual Studio , it now also found its way into VS Code. Planning mode, or as I like to call it 'Hannibal mode', extends GitHub Copilot's Agent Mode capabilities to handle larger, multi-step coding tasks with a structured approach. Instead of jumping straight into code generation, Planning mode creates a detailed execution plan. If you want more details, have a look at my previous post . Putting plan mode into action VS Code takes a different approach compared to Visual Studio when using plan mode. Instead of a configuration setting that you can activate but have limited control over, planning is available as a separate chat mode/agent: I like this approach better than how Visual Studio does it as you have explicit control when plan mode is activated. Instead of immediately diving into execution, the plan agent creates a plan and asks some follow up questions: You can further edit the plan by clicking on ‘Open in Editor’: ...
Read more