|- 擁有鎖的線程
lockObj->|- 就緒隊(duì)列(ready queue)
         |- 等待隊(duì)列(wait queue)

class Program
{
    static void Main(string[] args)
    {
        new Thread(A).Start();
        new Thread(B).Start();
        new Thread(C).Start();
        Console.ReadLine();
    }

    static object lockObj = new object();
    static void A()
    {
        lock (lockObj)               //進(jìn)入就緒隊(duì)列
        {
            Thread.Sleep(1000);
            Monitor.Pulse(lockObj);
            Monitor.Wait(lockObj);   //自我流放到等待隊(duì)列
        }
        Console.WriteLine("A exit...");
    }
    static void B()
    {
        Thread.Sleep(500);
        lock (lockObj)               //進(jìn)入就緒隊(duì)列
        {
            Monitor.Pulse(lockObj);
        }
        Console.WriteLine("B exit...");
    } 
    static void C()
    {
        Thread.Sleep(800);
        lock (lockObj)               //進(jìn)入就緒隊(duì)列
        {
        }
        Console.WriteLine("C exit...");
    }
}

T  線程A
0  lock( lockObj )
1  {
2     //...           線程B                   線程C
3     //...           lock( lockObj )       lock( lockObj )
4     //...           {                     {
5     //...              //...
6     //...              //...
7     Monitor.Pulse      //...
8     Monitor.Wait       //...
9     //...              Monitor.Pulse
10    //...           }                     }
11 }

時(shí)間點(diǎn)0，假設(shè)線程A先得到了同步對象，它就登記到同步對象lockObj的“擁有者引用”中。
時(shí)間點(diǎn)3，線程B和C要求擁有同步對象，他們將在“就緒隊(duì)列”排隊(duì)：
            |--(擁有鎖的線程) A
            |
3  lockObj--|--(就緒隊(duì)列)   B,C
            |
            |--(等待隊(duì)列)

時(shí)間點(diǎn)7，線程A用Pulse發(fā)出信號，允許第一個(gè)正在"等待隊(duì)列"中的線程進(jìn)入到”就緒隊(duì)列“。但由于就緒隊(duì)列是空的，什么事也沒有發(fā)生。
時(shí)間點(diǎn)8，線程A用Wait放棄同步對象，并把自己放入"等待隊(duì)列"。B,C已經(jīng)在就緒隊(duì)列中，因此其中的一個(gè)得以獲得同步對象（假定是B）。B成了同步

對象的擁有者。C現(xiàn)在還是候補(bǔ)委員，可以自動(dòng)獲得空缺。而A則被關(guān)在門外，不能自動(dòng)獲得空缺。
            |--(擁有鎖的線程) B
            |
8  lockObj--|--(就緒隊(duì)列)   C
            |
            |--(等待隊(duì)列)   A

時(shí)間點(diǎn)9，線程B用Pulse發(fā)出信號開門，第一個(gè)被關(guān)在門外的A被允許放入到就緒隊(duì)列，現(xiàn)在C和A都成了候補(bǔ)委員，一旦同步對象空閑，都有機(jī)會(huì)得它。
            |--(擁有鎖的線程) B
            |
9  lockObj--|--(就緒隊(duì)列)   C,A
            |
            |--(等待隊(duì)列)


時(shí)間點(diǎn)10，線程B退出Lock區(qū)塊，同步對象閑置，就緒隊(duì)列隊(duì)列中的C或A就可以轉(zhuǎn)正為擁有者（假設(shè)C得到了同步對象）。
            |--(擁有鎖的線程) C
            |
10 lockObj--|--(就緒隊(duì)列)   A
            |
            |--(等待隊(duì)列)

隨后C也退出Lock區(qū)塊，同步對象閑置，A就重新得到了同步對象，并從Monitor.Wait中返回...
最終的執(zhí)行結(jié)果就是：
B exit...
C exit...
A exit...

class MyManualEvent
{
    private object lockObj = new object();
    private bool hasSet = false;

    public void Set()
    {
        lock (lockObj)
        {
            hasSet = true;
            Monitor.PulseAll(lockObj);
        }
    }
    public void WaitOne()
    {
        lock (lockObj)
        {
            while (!hasSet)
            {
                Monitor.Wait(lockObj);
            }
        }
    }
}
class Program
{
    static MyManualEvent myManualEvent = new MyManualEvent();
    static void Main(string[] args)
    {
        ThreadPool.QueueUserWorkItem(WorkerThread, "A");
        ThreadPool.QueueUserWorkItem(WorkerThread, "B");
        Console.WriteLine("Press enter to signal the green light");
        Console.ReadLine();
        myManualEvent.Set();
        ThreadPool.QueueUserWorkItem(WorkerThread, "C");
        Console.ReadLine();
    }
    static void WorkerThread(object state)
    {
        myManualEvent.WaitOne();
        Console.WriteLine("Thread {0} got the green light...", state);
    }
}

lock(lockObj)
{
   //...
}
////相當(dāng)于（.Net4以前）：
Monitor.Enter(lockObj);
try
{
   //...
}
finally
{
   Monitor.Exit(lockObj);
}

lock(lockObj)
{
   //...
}
////相當(dāng)于（DotNet 4）：
bool lockTaken = false;
try
{
    Monitor.Enter(lockObj,ref lockTaken);
    //
}
finally
{
    if (lockTaken) Monitor.Exit(lockObj);
}

static object lockObj = new object();

static void A()
{

    lock (lockObj)               //進(jìn)入就緒隊(duì)列
    {
        //因?yàn)锳所在的線程Priority高，所以會(huì)先進(jìn)來
        Console.WriteLine("Into A lock block");

        Thread.Sleep(1000);

        //這里調(diào)用了Monitor.Pulse(lockObj)，會(huì)通知lockObj的等待隊(duì)列
        //但現(xiàn)在lockObj的等待隊(duì)列沒有線程在等待，所以通知不被處理
        Monitor.Pulse(lockObj);

        //自我流放到等待隊(duì)列                
        Monitor.Wait(lockObj);//同時(shí)此線程在此停止
        //線程此時(shí)的狀態(tài)是WaitSleepJoin

        //雖然在Monitor.Wait之前有Monitor.Pulse通知等待隊(duì)列，但是過期無效。
        //無論之前有多少個(gè)Monitor.Pulse

        //本線程在等待隊(duì)列后接受到Monitor.Pulse的通知時(shí)，線程回到就緒隊(duì)列
        //從就緒隊(duì)列中出來的時(shí)候，線程在此恢復(fù) 

    }
    Console.WriteLine("A exit...");
}

static void B()
{
    lock (lockObj)               //進(jìn)入就緒隊(duì)列
    {
        //B和C都在就緒隊(duì)列，因?yàn)锽所在的線程Priority比C高，所以會(huì)先進(jìn)來
        Console.WriteLine("Into B lock block");
        //這里調(diào)用了Monitor.Pulse(lockObj)，會(huì)通知lockObj的等待隊(duì)列
        //于此同時(shí)，A 已經(jīng)在等待隊(duì)列了
        Monitor.Pulse(lockObj);
        Console.WriteLine("B Call Pulse");
    }
    Console.WriteLine("B lock block exit...");
    Thread.Sleep(1);
    Console.WriteLine("B exit...");
}

static void C()
{
    //如果CPU是低負(fù)載理想的情況，此時(shí)的就緒隊(duì)列中會(huì)有兩個(gè)線程
    //除了C還有接收到信號的A，C排在前面理想情況會(huì)先進(jìn)來 但不是絕對，有時(shí)會(huì)是A 
    lock (lockObj)               //進(jìn)入就緒隊(duì)列
    {
        Console.WriteLine("Into C lock block");
    }
    Console.WriteLine("C exit...");
}

static void Main(string[] args)
{
    //設(shè)置Priority，確保按代碼順序執(zhí)行

    Thread a = new Thread(A);
    a.Priority = ThreadPriority.Highest;
    a.Start();

    Thread b = new Thread(B);
    b.Priority = ThreadPriority.Normal;
    b.Start();

    Thread c = new Thread(C);
    c.Priority = ThreadPriority.Lowest;
    c.Start();
             
    Console.ReadLine();
}

lock(lockObj)
{
   //...
}
////相當(dāng)于（DotNet 4）：
bool lockTaken = false;
try
{
    Monitor.Enter(lockObj,ref lockTaken);
    //
}
finally
{
    if (lockTaken) Monitor.Exit(lockObj);
}