线程学习7——lock语句
什么是lock语句?
lock语句是设置锁定和解除锁定的一种简单方式。
为什么使用lock语句?
在使用多线程的过程中,会出现很多难以发现的问题,比如竞态条件与死锁,为了避免这些同步问题,所以使用lock语句,当然这并不是解决同步问题的唯一方法。
lock语句的作用:
lock 关键字可确保当一个线程位于代码的临界区时,另一个线程不会进入该临界区。 如果其他线程尝试进入锁定的代码,则它将一直等待(即被阻止),直到该对象被释放。
lock语句的用法:
lock 关键字将语句块标记为临界区,方法是获取给定对象的互斥锁,执行语句,然后释放该锁。 此语句的形式如下:
Object thisLock = new Object();
lock (thisLock)
{
// Critical code section.
}
lock语句的注意事项:
最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。
-
如果实例可以被公共访问,将出现 lock (this) 问题。
第一种情况:
1.同一个对象,不同线程。lock (this) 不会出现问题的例子
class MyMainClass
{
private static readonly object lockHelper = new object();
private static int num = 0; //记录不同线程操作的次数
private int count = 0; //记录每个对象执行次数
static void Main()
{
//一个对象
MyMainClass c1 = new MyMainClass();
//两个线程
Thread myThread1 = new Thread(new ThreadStart(c1.DoSomething));
myThread1.Name = "FirstThread";
myThread1.Start();
Thread myThread2 = new Thread(new ThreadStart(c1.DoSomething));
myThread2.Name = "SecondThread";
myThread2.Start();
Console.WriteLine("C1 count: {0}", c1.count);
Console.ReadLine();
}
public void DoSomething()
{
//此处可以用this,或者也可以用lockHelper
lock (this)
{
while (num < 100)
{
num++;
Console.WriteLine("{0} add value: {1}", Thread.CurrentThread.Name, num);
count++;
}
}
}
}
class MyMainClass
{
private static readonly object lockHelper = new object();
private static int num = 0; //记录不同线程操作的次数
private int count = 0; //记录每个对象执行次数
static void Main()
{
//两个对象
MyMainClass c1 = new MyMainClass();
MyMainClass c2 = new MyMainClass();
//两个线程
Thread myThread1 = new Thread(new ThreadStart(c1.DoSomething));
myThread1.Name = "FirstThread";
myThread1.Start();
Thread myThread2 = new Thread(new ThreadStart(c2.DoSomething));
myThread2.Name = "SecondThread";
myThread2.Start();
Console.WriteLine("C1 count: {0}", c1.count);
Console.WriteLine("C2 count: {0}", c2.count);
Console.ReadLine();
}
public void DoSomething()
{
//lock (this)
//此处只可以用lockHelper,若用this则锁不住
lock (lockHelper)
{
while (num < 100)
{
num++;
Console.WriteLine("{0} add value: {1}", Thread.CurrentThread.Name, num);
count++;
}
}
}
}
第二种情况:如果一个类是公有的时,应该避免在基方法或属性中使用lock(this)语句,因为如果有其他人使用你的组件,
它并不了解你的组件内部是否使用了锁,当组件内部使用了锁,而使用者又在类外部对类实例尝试加锁,则可能导致一个死锁。
例如:
public class InternalClass
{
.....
private void ThreadFunction()
{
......
lock (this)
{
......
}
}
}
public class ClassMain
{
private InternalClass theClass = new InternalClass();
public ClassMain()
{
lock (theClass) // 如果注释掉这句,ThreadFunction()中的lock将执行成功
{
Console.WriteLine("对象被锁定, 在这里我们获得了一个死锁...");
}
}
}
static void Main(string[] args)
{
ClassMain cm = new ClassMain();
Console.WriteLine("Press Enter to exit");
Console.ReadLine();
}
因此,应尽量避免甚至拒绝使用lock(this)这样的语句。
-
如果 MyType 可以被公共访问,将出现 lock (typeof (MyType)) 问题。
lock (typeof (MyType))
Type t1 = typeof(MyType),
Type t2 = typeof(MyType),
这样的两个t1,t2,引用是相等的,跟lock(this)会产生同样的问题.
-
由于进程中使用同一字符串的任何其他代码都将共享同一个锁,所以出现 lock("myLock") 问题。
例如:
string a = "String Example";string b = "String Example";
string c = (new StringBuilder()).Append("String Example").ToString();
Console.WriteLine("a==b? {0}", object.ReferenceEquals(a, b));
Console.WriteLine("a==c? {0}", object.ReferenceEquals(a, c));
上面程序执行的结果是:
a==b? True
a==c? False
从上面可以看出,a和b指向的是同一个引用,而lock正是通过引用来区分并加锁临界代码段的。也就是说,如果在我们一程序的一个部分中使用了 lock("thisLock")进行加锁,而在程序的另一个位置同样也使用lock("thisLock")进行加锁,则极有可能导致一个死锁,因而是很危险的。实际上,不只是lock("thisLock")这样的语句,在lock中使用string类型的引用都有可能导致死锁。