----------
20181117
volatile vs Interlocked vs lock

ref:
https://stackoverflow.com/questions/154551/volatile-vs-interlocked-vs-lock

Let's say that a class has a public int counter field that is accessed by multiple threads. This int is only incremented or decremented.

To increment this field, which approach should be used, and why?
•lock(this.locker) this.counter++;,
•Interlocked.Increment(ref this.counter);,
•Change the access modifier of counter to public volatile.

Now that I've discovered volatile, I've been removing many lock statements and the use of Interlocked. But is there a reason not to do this?


Worst (won't actually work)
Change the access modifier of counter to public volatile
最差方案 (不可行): 使用 public volatile

As other people have mentioned, this on its own isn't actually safe at all. The point of volatile is that multiple threads running on multiple CPUs can and will cache data and re-order instructions.
volatie模式不可行的原因是, 多CPU執行多執行緒時, 會快取且重排指令. 

If it is not volatile, and CPU A increments a value, then CPU B may not actually see that incremented value until some time later, which may cause problems.
在非volatile模式時, 當CPU A增加數值, 但是CPU B 不一定能即時得到最新的結果, 必須等待一段時間, 因此會有問題.

If it is volatile, this just ensures the two CPUs see the same data at the same time. It doesn't stop them at all from interleaving their reads and write operations which is the problem you are trying to avoid.
若在volatile模式時, 則只能保證不同的cpu可以得到最新的運算結果. 但無法停止讀寫的期間, 仍會存在不一致的問題.

Second Best:
lock(this.locker) this.counter++;
次佳方案: 使用lock. (較慢, 須注意別鎖死)

This is safe to do (provided you remember to lock everywhere else that you access this.counter). It prevents any other threads from executing any other code which is guarded by locker. Using locks also, prevents the multi-CPU reordering problems as above, which is great.
使用安全. (在每一個讀寫 this.counter計數器時鎖定). 這樣可避免不同的執行緒也同時讀寫. 使用lock指令也同時避開了多CPU重排指令的問題.

The problem is, locking is slow, and if you re-use the locker in some other place which is not really related then you can end up blocking your other threads for no reason.
使用lock指令的問題是很慢. 並且當不同的地方重複鎖定時, 會導致鎖死的現象.

Best
Interlocked.Increment(ref this.counter);
最佳方案: 使用Interlocked.Increment(ref this.counter);

This is safe, as it effectively does the read, increment, and write in 'one hit' which can't be interrupted. Because of this, it won't affect any other code, and you don't need to remember to lock elsewhere either. It's also very fast (as MSDN says, on modern CPUs, this is often literally a single CPU instruction).
這是安全的方法(有效率讀取, 增加, 寫入在(單一不可中斷). 因此, 不會影響其他的程式, 也不用多記憶還有哪裡有lock. 並且執行速度也很快. 依據MSDN, 在主流的CPU, 通常只需要一個cpu指令週期. 

InterlockedNotes:
1.INTERLOCKED METHODS ARE CONCURRENTLY SAFE ON ANY NUMBER OF COREs OR CPUs.
2.Interlocked methods apply a full fence around instructions they execute, so reordering does not happen.
3.Interlocked methods do not need or even do not support access to a volatile field, as volatile is placed a half fence around operations on given field and interlocked is using the full fence.

Footnote: What volatile is actually good for.
volatile適用的需求:

As volatile doesn't prevent these kinds of multithreading issues, what's it for? A good example is saying you have two threads, one which always writes to a variable (say queueLength), and one which always reads from that same variable.

If queueLength is not volatile, thread A may write five times, but thread B may see those writes as being delayed (or even potentially in the wrong order).

A solution would be to lock, but you could also use volatile in this situation. This would ensure that thread B will always see the most up-to-date thing that thread A has written. Note however that this logic only works if you have writers who never read, and readers who never write, and if the thing you're writing is an atomic value. As soon as you do a single read-modify-write, you need to go to Interlocked operations or use a Lock.







----------
20170102

volatile

URL: 
http://svc.luckstar.com.tw/CodeHelper/cs/KeyWord/volatile.txt
Reference: 
https://msdn.microsoft.com/en-us/library/x13ttww7(v=vs.140).aspx

volatile關鍵字, 表示不同的執行緒, 可能會同時修改同一個變數. 
指定為volatile的變數, 編譯器就不會做最佳化處理, 並且會假設是在同一個執行緒中執行, 以維持最新的修改內容.
volatile通常是用在(多執行緒且不使用lock指令)環境中, 控制執行順序.

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 shows how to declare a public field variable as volatile

  
    class VolatileTest
    {
        public volatile int i;

        public void Test(int _i)
        {
            i = _i;
        }
    }

----------
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.

using System;
using System.Threading;

public class Worker
{
    // This method is called when the thread is started.
    public void DoWork()
    {
        while (!_shouldStop)
        {
            Console.WriteLine("Worker thread: working...");
        }
        Console.WriteLine("Worker thread: terminating gracefully.");
    }
    public void RequestStop()
    {
        _shouldStop = true;
    }
    // Keyword volatile is used as a hint to the compiler that this data
    // member is accessed by multiple threads.
    private volatile bool _shouldStop;
}

public class WorkerThreadExample
{
    static void Main()
    {
        // Create the worker thread object. This does not start the thread.
        Worker workerObject = new Worker();
        Thread workerThread = new Thread(workerObject.DoWork);

        // Start the worker thread.
        workerThread.Start();
        Console.WriteLine("Main thread: starting worker thread...");

        // Loop until the worker thread activates.
        while (!workerThread.IsAlive) ;

        // Put the main thread to sleep for 1 millisecond to
        // allow the worker thread to do some work.
        Thread.Sleep(1);

        // Request that the worker thread stop itself.
        workerObject.RequestStop();

        // Use the Thread.Join method to block the current thread 
        // until the object's thread terminates.
        workerThread.Join();
        Console.WriteLine("Main thread: worker thread has terminated.");
    }
    // Sample output:
    // Main thread: starting worker thread...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: working...
    // Worker thread: terminating gracefully.
    // Main thread: worker thread has terminated.
}