8.4 Volatile fields

Like Java, C# has a volatile keyword for modifying fields only. This special modifier is usually used only in multi-threaded programming. Threads might cache the values of member fields for efficiency and, since threads can share the same field, it might be possible that a particular thread's cache field value is out of sync with the actual field's value. This is especially so if other concurrently running threads update the field of a shared object.

In both Java and C#, declaring a field as volatile tells the compiler that it should not attempt to perform optimizations (such as caching) on the field. The system always reads the current (latest) value of a volatile field at the point it is requested , and writes the value of the field immediately on assignment.

You declare a field as volatile by inserting the volatile keyword in front, as with all other modifiers. The following statement declares temp as a public static int variable which is also volatile: public static volatile int temp;

Like Java

• You inform the compiler not to optimize a shared field by declaring it as volatile.

• You should declare fields which are shared by multiple concurrently-running threads as volatile “ this is especially so if this field is not synchronized within a lock block. ^[8]

  ^[8] A C# lock block is similar to a synchronized block in Java. A locked block is protected by an object mutex, and can only be assessed by any single thread at only one time. See Chapter 17.

Additional notes

• A volatile field cannot be passed to a ref or out parameter of a method (see section 7.2.2).

  The following will cause a compilation error:

   1: class TestClass{  2:    private  volatile  int MyInt;  3:  4:    public void DoThis(  ref  int i){  5:    }  6:  7:    public static void Main(){  8:      TestClass tc = new TestClass();  9:      tc.MyInt = 3; 10:     tc.DoThis(  ref  tc.MyInt); 11:   } 12:  } 

  Compilation error:

   test.cs(10,19): error CS0676: Cannot pass volatile field 'TestClass.MyInt' as ref or out, or take its address 

• A volatile field cannot be read-only as well. The following declaration results in the compilation error ' A field can not be both volatile and readonly' :

   public readonly volatile bool b; 

  Likewise, you cannot declare a constant as volatile. ^[9]

  ^[9] A volatile constant doesn't make sense since you cannot change a constant's value.

• The type of a field marked as volatile can only be of the following:

  - any reference type;

  - a pointer type (within an unsafe context) “ see section 9.1;

  - the following simple (primitive) types only: sbyte , byte , short , ushort , int , uint , char , float , bool ;

  - an enum (see Chapter 25) type with an enum base type of sbyte , byte , short , ushort , int and uint .