Volatile keyword parsing of C ＃

One , Conceptual explanation

volatile  Keyword indicates that a field can be modified by multiple threads executing at the same time .

For performance reasons , compiler , At run time, the system and even the hardware may rearrange the reads and writes to the memory location .  The statement  volatile  The fields of are not optimized .

add to  volatile  The modifier ensures that all threads observe volatile writes （ Executed by any other thread ） The order of observation is consistent with the order of execution of the write operation .  It is not ensured that all volatile writes are sorted in execution order when viewed from all execution threads as a whole .

Two , Type of embellishment

volatile  Keywords can be decorated in the following types of fields ：

• Reference type .

• Simple type , Such as sbyte、byte、short、ushort、int、uint、char、float  and  bool.

• With one of the following basic types  enum  type ：byte、sbyte、short、ushort、int  or  uint.

• Generic type parameters known as reference types .

• IntPtr  and  UIntPtr.

Other types （

Include  double  and  long

） Cannot be marked as  volatile,

Because reading and writing to these types of fields is not guaranteed to be atomic .

  To protect multithreaded access to these types of fields , You can use  Interlocked  Class members or use  lock  Statement to protect access .

volatile  Keywords can only be applied to  class  or  struct  Field of .  And you cannot declare a local variable as  volatile.

3、 ... and , Practical application

Usually, we use the singleton pattern like this , The code is as follows ：

/// <summary>
///  Single case
/// </summary>
class Singleton
{
 private static Singleton _ins;

 public static Singleton Instance
 {
 get
 {
 if (_ins == null)
 {
 _ins = new Singleton();
 }
 return _ins;
 }
 }

 //  Privatized structure
 private Singleton() { }

}


If our program needs to execute in multithreading , There may be problems with the above writing , One extreme case is , Two threads enter at the same time

if (_ins == null)

when , This will new  Two objects come out , This is obviously against our intention to use singleton mode , Then optimize the following single example writing , Use in multithreading

 /// <summary>
 ///  Multithreaded singleton
 /// </summary>
 class SingletonThread
 {
 private static volatile SingletonThread _ins;

 private static object lockHelper = new Object { };

 public static SingletonThread Instance
 {
 get
 {
 if(_ins == null)
 {
 lock (lockHelper)
 {
 if(_ins == null)
 _ins = new SingletonThread();
 }
 }
 return _ins;
 }
 }

 //  Privatized structure
 private SingletonThread() { }
}