C#线程(四、简单的同步)

转自：见证大牛成长之路(http://blog.youkuaiyun.com/shanyongxu/article/details/47982419),本文为本人学习用，请点击链接查看原文，尊重楼楼大大版权。

简单的同步

看下面这一段代码:

class ThreadTest  
    {  
        static int _val1 = 1, _val2 = 1;  
        internal static void Go()  
        {  
            if (_val2!=0)  
            {  
                Console.WriteLine(_val1/_val2);  
            }  
            _val2 = 0;  
        }  
}  

分析:乍一看,没问题啊,但是我要告诉你,这段代码是 费线程安全的,假设两个线程A和B,A和B都执行到了Go()方法的if判断中,假设_val2=1.所以两个线程都通过了了if判断,线程A执行了CW语句,然后退出了if语句,执行_val2=0,此时val2=0,但是此时线程B才刚刚执行到CW方法,而此时_val2=0.所以你有可能会得到一个divide by zero的异常.
 
so, 为了保证线程安全,我们可以使用lock关键字,例如:

class ThreadTest  
{  
    static readonly object _locker = new object();  
    static int _val1 = 1, _val2 = 1;  
    internal static void Go()  
    {  
        lock (_locker)  
        {  
            if (_val2 != 0)  
            {  
                Console.WriteLine(_val1 / _val2);  
            }  
            _val2 = 0;  
        }  
  
    }  
}  

分析:此时两个线程A和B都只能有一个可以获得_locker锁,所以只能有一个线程来执行lock块的代码.
 
C#的lock关键字实际上是Moitor.Enter和Monitor.Exit的缩写.例如上面所写的代码和下面的等价:

Monitor.Enter(_locker);  
            try  
            {  
                if (_val2 != 0)  
                {  
                    Console.WriteLine(_val1 / _val2);  
                }  
                _val2 = 0;  
            }  
            finally { Monitor.Exit(_locker); }  

注意,如果在调用Monitor.Exit之前没有调用Monitor.Enter,则会抛出一个异常.
 
还有,在Monitor.Enter和try方法之间可能会抛出异常.例如在线程上调用Abort,或者是OutOfMemoryException.
 
为了解决这个问题,CLR 4.0提供了Monitor.Enter的重载,增加了lockTaken字段,当Monitor.Enter成果获取锁之后,lockTaken就是True,否则就为false.
 
我们同样可以将上面的代码写成下面这样:

class ThreadTest  
{  
    static readonly object _locker = new object();  
    static int _val1 = 1, _val2 = 1;  
    internal static void Go()  
    {  
          
        bool lockTaken = false;  
        try  
        {  
            Monitor.Enter(_locker,ref lockTaken);  
            if (_val2 != 0)  
            {  
                Console.WriteLine(_val1 / _val2);  
            }  
            _val2 = 0;  
        }  
        finally  
        {  
            if (lockTaken)  
            {  
                Monitor.Exit(_locker);  
            }  
              
        }  
  
    }  
}  

Monitor也提供了TryEnter方法,并且可以传递一个超时时间.如果方法返回true,则代表获取了锁,否则为false.

选择同步对象

Monitor.Enter方法的参数是一个object类型,所以任何对象都可以是同步的,考虑下面的代码:  
int i=5;    lock(i){}   //锁定值类型  
lock(this){}    //锁定this对象  
lock(typeof(Product)){}//锁定type对象  
string str=”ddd”;   lock(str){} //锁定字符串  

锁定值类型会将值类型进行装箱,所以Monitor.Enter进入的是一个对象,但是Monitor.Exit()退出的是另一个不同的对象.
 
锁定this和type对象,会导致无法控制锁的逻辑,并且它很难保证不死锁和频繁的阻塞,在相同进程中锁定type对象会穿越应用程序域.
 
由于字符串驻留机制,所以也不要锁定string.
 

嵌套锁
 
同一个线程可以多次锁定同一对象.例如

lock(locker)  
    lock(locker)  
        lock(locker)  
        {  
            // do something  
　　　　　}  

或者是

Monitor.Enter(locker);  
Monitor.Enter(locker);  
Monitor.Enter(locker);  
//code  
Monitor.Exit(locker);  
Monitor.Exit(locker);  
Monitor.Exit(locker);  

当一个线程使用一个锁调用另一个方法的时候,嵌套锁就非常的有用.例如:

static readonly object _locker = new object();  
static void Main(string[] args)  
{  
  
    lock (_locker)  
    {  
        Method();  
    }  
  
}  
static void Method()  
{  
    lock (_locker)  
    {  
        //code  
    }  
}  

死锁
 
先看这样的代码

static readonly object locker1 = new object();  
        static readonly object locker2 = new object();  
          
        public static void MainThread()  
        {  
            new Thread(() =>  
            {  
                lock (locker1)   //获取锁locker1  
                {  
                    Thread.Sleep(1000);  
                    lock (locker2)//尝试获取locker2  
                    {  
                        Console.WriteLine("locker1   locker2");  
                    }  
                }  
            }).Start();  
   
            lock (locker2)//获取锁loccker2  
            {  
                Thread.Sleep(1000);//尝试获取locker1  
                lock (locker1)  
                {  
                    Console.WriteLine("locker2     locker1");  
                }  
            }  
        }  

分析:在这里,主线程先获取locker2的锁,然后sleep,接着尝试获取locker1的锁.副线程先获取locker1的锁,然后sleep,接着尝试获取locker2的锁.程序进入死锁状态,两个线程都在等待对方释放自己等待的锁.
 
CLR作为一个独立宿主环境,它不像SQL Server一样,他没有自动检测死锁机制,也不会结束一个线程来破坏死锁.死锁的线程会导致部分线程无限的等待.
 
 
 小结一下
个人感觉那个死锁的案例,需要记住,记住代码。

再次声明：
转自：见证大牛成长之路(http://blog.youkuaiyun.com/shanyongxu/article/details/47982419),本文为本人学习用，请点击链接查看原文，尊重楼楼大大版权。