简单的同步
前言
好几天没写写C#的代码了,突发奇想,还是写写吧,别手生了.还是继续写点关于线程的小东西吧,这次说说线程的同步吧.
看下面这一段代码
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一样,他没有自动检测死锁机制,也不会结束一个线程来破坏死锁.死锁的线程会导致部分线程无限的等待.
小小的结一下
个人感觉那个死锁的案例,需要记住,记住代码
版权声明：本文为博主原创文章，未经博主允许不得转载。