Monitor的code如下，非常简单：

public static class Monitor {    public static extern void Enter(Object obj);    public static void Enter(Object obj, ref bool lockTaken)    {        if (lockTaken)            ThrowLockTakenException();        ReliableEnter(obj, ref lockTaken);        Contract.Assert(lockTaken);    }    private static extern void ReliableEnter(Object obj, ref bool lockTaken);    public static void TryEnter(Object obj, ref bool lockTaken)    {        if (lockTaken)            ThrowLockTakenException();        ReliableEnterTimeout(obj, 0, ref lockTaken);    }    private static extern void ReliableEnterTimeout(Object obj, int timeout, ref bool lockTaken);        public static extern void Exit(Object obj);            public static bool Wait(Object obj, int millisecondsTimeout, bool exitContext)    {        if (obj == null)            throw (new ArgumentNullException("obj"));        return ObjWait(exitContext, millisecondsTimeout, obj);    }    private static extern bool ObjWait(bool exitContext, int millisecondsTimeout, Object obj);    public static void Pulse(Object obj)    {        if (obj == null)        {            throw new ArgumentNullException("obj");        }        Contract.EndContractBlock();        ObjPulse(obj);    }    private static extern void ObjPulse(Object obj);            public static void PulseAll(Object obj)    {        if (obj == null)        {            throw new ArgumentNullException("obj");        }        Contract.EndContractBlock();        ObjPulseAll(obj);    }    private static extern void ObjPulseAll(Object obj);        public static bool IsEntered(object obj)    {        if (obj == null)            throw new ArgumentNullException("obj");        return IsEnteredNative(obj);    }   private static extern bool IsEnteredNative(Object obj);    }

核心方法就是Enter和Exit，其中lock关键字就是这2个方法的一个封装，剩下的Wait、Pulse和PulseAll也是很重要的方法，但是平时运用的比较少。所以这里重点说说Wait、Pulse和PulseAll方法。

线程优先顺序： 【等待队列】->【就绪队列】->【拥有锁线程】这个是重点,下文多次会提到，其中的微妙关系的核心也来源于这个执行顺序。

MSDN官方备注：同步的对象包含若干引用，其中包括对当前拥有锁的线程的引用、对就绪队列的引用和对等待队列的引用。我的提醒：竞争对象锁的线程都是处于就绪队列中。

1.Monitor.Wait方法

当线程调用 Wait 时，它释放对象的锁并进入对象的等待队列，对象的就绪队列中的下一个线程（如果有）获取锁并拥有对对象的独占使用。Wait()就是交出锁的使用权，使线程处于阻塞状态，直到再次获得锁的使用权。

2.Monitor.Pulse方法

当前线程调用此方法以便向队列中的下一个线程发出锁的信号。接收到脉冲后，等待线程就被移动到就绪队列中。在调用 Pulse 的线程释放锁后，就绪队列中的下一个线程（不一定是接收到脉冲的线程）将获得该锁。pulse（）并不会使当前线程释放锁。

当一个线程尝试着lock一个同步对象的时候，该线程就在就绪队列中排队。一旦没人拥有该同步对象，就绪队列中的线程就可以占有该同步对象。这也是我们平时最经常用的lock方法。为了其他的同步目的，占有同步对象的线程也可以暂时放弃同步对象，并把自己流放到等待队列中去，这就是Monitor.Wait；由于该线程放弃了同步对象，其他在就绪队列的排队者就可以进而拥有同步对象。比起就绪队列来说，在等待队列中排队的线程更像是二等公民：他们不能自动得到同步对象，甚至不能自动升舱到就绪队列。而Monitor.Pulse的作用就是开一次门，使得一个正在等待队列中的线程升舱到就绪队列；相应的Monitor.PulseAll则打开门放所有等待队列中的线程到就绪队列。

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) //进入就绪队列             {                Thread.Sleep(1000);                Monitor.Pulse(lockObj);                Monitor.Wait(lockObj); //自我流放到等待队列            }            Console.WriteLine("A exit...");        }        static void B()        {            Thread.Sleep(500);            lock (lockObj) //进入就绪队列             {                Monitor.Pulse(lockObj);            }            Console.WriteLine("B exit...");        }        static void C()        {            Thread.Sleep(800);            lock (lockObj) //进入就绪队列             { }            Console.WriteLine("C exit...");        }    }

假设线程A先得到了同步对象，它就登记到同步对象lockObj的“拥有者引用”中。线程B和C要求拥有同步对象，他们将在“就绪队列”排队，|--(拥有锁的线程) A | |--(就绪队列) B,C | |--(等待队列)。

线程A用Pulse发出信号，允许第一个正在"等待队列"中的线程进入到”就绪队列“。但由于等待列是空的，什么事也没有发生。线程A用Wait放弃同步对象，并把自己放入"等待队列"。B,C已经在就绪队列中，因此其中的一个得以获得同步对象（假定是B）。B成了同步对象的拥有者。C现在还是候补委员，可以自动获得空缺。而A则被关在门外，不能自动获得空缺。 |--(拥有锁的线程) B ||--(就绪队列) C | |--(等待队列) A

线程B用Pulse发出信号开门，第一个被关在门外的A被允许放入到就绪队列，现在C和A都成了候补委员，一旦同步对象空闲，都有机会得它。 |--(拥有锁的线程) B | |--(就绪队列) C,A | |--(等待队列)

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 Program2    {        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);        }    }

我们看到了该玩具MyManualEvent实现了类库中的ManulaResetEvent的功能，但却更加的轻便，类库的ManulaResetEvent使用了操作系统内核事件机制，负担比较大（不算竞态时间，ManulaResetEvent是微秒级，而lock是几十纳秒级。例子的WaitOne中先在lock的保护下判断是否信号绿灯，如果不是则进入等待。因此可以有多个线程(比如例子中的AB）在等待队列中排队。当调用Set的时候，在lock的保护下信号转绿，并使用PulseAll开门放狗，将所有排在等待队列中的线程放入就绪队列，A或B（比如A）于是可以重新获得同步对象，从Monitor.Wait退出，并随即退出lock区块，WaitOne返回。随后B或A（比如B）重复相同故事，并从WaitOne返回。线程C在myManualEvent.Set()后才执行，它在WaitOne中确信信号灯早已转绿，于是可以立刻返回并得以执行随后的命令。该玩具MyManualEvent可以用在需要等待初始化的场合，比如多个工作线程都必须等到初始化完成后，接到OK信号后才能开工。该玩具MyManualEvent比起ManulaResetEvent有很多局限，比如不能跨进程使用，但它演示了通过基本的Monitor命令组合，达到事件机的作用。