沒想到我的前兩篇文章還挺受歡迎的，謝謝大家，今天整理下Mutex的使用。

一：Mutex

首先看下MSDN對它的解釋：

不錯，出現了一個亮點，可用於“進程間同步“，既然進程間都可以同步，那線程同步對它來說不是小菜一碟嗎？好的，還是看下Mutex在

線程中發揮的神奇功效。

1: 線程間同步

Metux中提供了WatiOne和ReleaseMutex來確保只有一個線程來訪問共享資源，是不是跟Monitor很類似，下面我還是舉個簡單的例子，

註意我並沒有給Metux取名字。

 1 class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             for (int i = 0; i < 20; i++)
 6             {
 7                 Thread t = new Thread(Run);
 8 
 9                 t.Start();
10             }
11 
12             Console.Read();
13         }
14 
15         static int count = 0;
16 
17         static Mutex mutex = new Mutex();
18 
19         static void Run()
20         {
21             Thread.Sleep(100);
22 
23             mutex.WaitOne();
24 
25             Console.WriteLine("當前數字：{0}", ++count);
26 
27             mutex.ReleaseMutex();
28         }
29     }

2：進程間同步

這次我給Mutex取個名字叫cnblogs，把Console程序copy一份，然後看看真的能夠實現進程同步嗎？

 1  class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Thread t = new Thread(Run);
 6 
 7             t.Start();
 8 
 9             Console.Read();
10         }
11 
12         static Mutex mutex = new Mutex(false, "cnblogs");
13 
14         static void Run()
15         {
16             mutex.WaitOne();
17 
18             Console.WriteLine("當前時間：{0}我是線程:{1}，我已經進去臨界區", DateTime.Now, Thread.CurrentThread.GetHashCode());
19 
20             //10s
21             Thread.Sleep(10000);
22 
23             Console.WriteLine("\n當前時間:{0}我是線程:{1}，我準備退出臨界區", DateTime.Now, Thread.CurrentThread.GetHashCode());
24 
25             mutex.ReleaseMutex();
26         }
27     }

3: 小結

①： 當給Mutex取名的時候能夠實現進程同步，不取名實現線程同步，詳細細節參考MSDN:

②： Mutex封裝了win32的同步機制，而Monitor是由framework封裝，所以在線程同步角度來說，Monitor更加短小精悍，優於Mutex，要是實現進程

同步，Monitor也幹不了，所以Mutex是首選。

二：Interlocked

同樣先向MSDN討個說法，看看如何解釋。

”原子操作”是個亮點，我們知道“原子”是不可再分的，深一點的意思就是說站在程序員的角度來看是不需要手工幹預的，也就是所謂的“無鎖編程”。

實際應用中有時候我們可能只是對共享變量進行一些簡單的操作，比如說“自增，自減，求和,賦值，比較"。

1：Increment

看看是不是達到了不可再分的自增效果，蠻有意思。

 class Program
    {
        static void Main(string[] args)
        {
            for (int i = 0; i < 20; i++)
            {
                Thread t = new Thread(Run);

                t.Start();
            }

            Console.Read();
        }

        static int count = 0;

        static Mutex mutex = new Mutex();

        static void Run()
        {
            Thread.Sleep(100);

            Console.WriteLine("當前數字：{0}", Interlocked.Increment(ref count));
        }
    }

2:Decrement

這個就不用舉例子了。

3：Add

發現MSDN解釋的還是蠻詳細的。

1      static void Main(string[] args)
2         {
3             int i = 10;
4 
5             Interlocked.Add(ref i, 20);
6 
7             Console.WriteLine(i);  //i=30
8         }

4：Exchange

這個就是所謂的原子性賦值操作

1  static void Main(string[] args)
2         {
3             int i = 10;
4 
5             Interlocked.Exchange(ref i, 30);
6 
7             Console.WriteLine(i);  //i=30
8         }

5:CompareExchange

所謂的比較操作，還是看看經典的MSDN的說法

如果相等，返回第二個參數值：

  static void Main(string[] args)
        {
            int i = 10;

            Interlocked.CompareExchange(ref i, 30, 10);

            Console.WriteLine(i);  //i=30
        }

如果不相等，則返回原始值：

1  static void Main(string[] args)
2         {
3             int i = 10;
4 
5             Interlocked.CompareExchange(ref i, 30, 100);
6 
7             Console.WriteLine(i);  //i=10
8         }

轉載地址：http://www.cnblogs.com/huangxincheng/archive/2012/03/16/2402320.html

【轉載】5天不再懼怕多線程——第三天 互斥體