C#线程系列讲座(5)：同步技术之Monitor

转自：http://www.cnblogs.com/nokiaguy/archive/2008/07/31/1257625.html

 在上一讲介绍了使用lock来实现线程之间的同步。实际上，这个lock是C#的一个障眼法，在C#编译器编译lock语句时，将其编译成了调用Monitor类。先看看下面的C#源代码：

public   static   void  MyLock()
{
     lock  ( typeof (Program))
    {
    }
}

    上面的代码通过lock语句使MyLock同步，这个方法被编译成IL后，代码如图1所示。

                                                         图1

    从上图被标注的区域可以看到，一条lock语句被编译成了调用Monitor的Enter和Exit方法。Monitor在System.Threading命名空间中。lock的功能就相当于直接调用Monitor的Entry方法，所不同的是，lock方法在结束后，会自动解除锁定，当然，在IL中是调用了Monitor的Exit方法，但在C#程序中，看起来是自动解锁的，这类似于C#中的using语句，可以自动释放数据库等的资源。但如果直接在C#源程序中使用Monitor类，就必须调用Exit方法来显式地解除锁定。如下面的代码所示：

Monitor.Entry(lockObj);
try
{
     //  lockObj的同布区
}
catch (Exception e)
{
     //  异常处理代码
}
finally
{
    Monitor.Exit(lockObj);   //  解除锁定
}

    Exit方法最后在finally里调用，这样无论在方法在发生异常、返回还是正常执行，都会执行到finally，并调用Exit方法解除锁定。

    Monitor类不仅可以完全取代lock语句（如果只使用lock语句本身的功能，最好还是直接用lock语句吧），还可以使用TryEntry方法设置一个锁定超时，单位是毫秒。如下面的代码所示：

if (Monitor.TryEntry(lockObj,  1000 ))
{
     try
    {
    }
     finally
    {
        Monitor.Exit(lockObj);
    }
}
else
{
     //  超时后的处理代码
}

    上面的代码设置了锁定超时时间为1秒，也就是说，在1秒中后，lockObj还未被解锁，TryEntry方法就会返回false，如果在1秒之内，lockObj被解锁，TryEntry返回true。我们可以使用这种方法来避免死锁，如下面的代码所示：

     class  Program
    {
         private   static  Object objA  =   new  Object();
         private   static  Object objB  =   new  Object();
         public   static   void  LockA()
        {
             if  (Monitor.TryEnter(objA,  1000 ))
            {
                Thread.Sleep( 1000 );
                 if  (Monitor.TryEnter(objB,  2000 ))
                {
                    Monitor.Exit(objB);
                }
                 else
                {

                    Console.WriteLine( " LockB timeout " );
                }
                Monitor.Exit(objA);
            }
            Console.WriteLine( " LockA " );
        }
         public   static   void  LockB()
        {
             if  (Monitor.TryEnter(objB,  2000 ))
            {
                Thread.Sleep( 2000 );
                 if  (Monitor.TryEnter(objA,  1000 ))
                {
                    Monitor.Exit(objA);
                }
                 else
                {
                    Console.WriteLine( " LockA timeout " );
                }
                Monitor.Exit(objB);
            }
            Console.WriteLine( " LockB " );
        }
         public   static   void  Main()
        {
            Thread threadA  =   new  Thread(LockA);
            Thread threadB  =   new  Thread(LockB);
            threadA.Start();
            threadB.Start();
            Thread.Sleep( 4000 );         
            Console.WriteLine( " 线程结束 " );
        }
    }

    上面的代码是在上一讲举的死锁的例子，但在这一讲将lock语句改成了TryEntry方法，而且设置了锁定超时间，由于在等待一定时间后，不管被锁定的对象是否被解锁，TryEntry方法都会返回，因此，上面的代码是不会死锁的。运行上面的代码的结果如图2所示。

                                              图2

    如果TryEntry方法的超时时间为System.Threading.Timeout.Infinite，TryEntry方法就相当于Entry方法，如果超时时间为0，不管是否解锁，TryEntry方法都会立即返回。

实际上，在拥有某个对象锁的线程内调用Wait方法，就相当于暂时将被锁定的对象释放，然后将调用Wait方法的线程放到等待队列中。这时其他等待刚才被释放的对象锁的线程就会获得这个对象。如果对这个对象调用Pulse方法，就会通知等待队列中曾经在这个对象上调用Wait方法的第一个线程（栈顶的线程）可以重新获得这对象锁，但系统只是将这个线程从等待队列放到就绪队列中，至于什么时候这个线程会重新获得对象锁，就由系统调度算法决定了。如下面的代码如示：
private Object obj = new Object();
private void method1()
{
lock(obj)
{
Monitor.Wait(obj); // 将method1所在的线程放到等待队列中
}
}

private void method2()
{
lock(obj)
{
// 当在method1方法中调用Wait时，method2所在的线程可能会获得obj锁
}
}

private void method3()
{
Monitor.Pulse(obj);// 通知method1所在的线程可以获得obj锁了，但这个程被放在了就绪队列中
}