线程学习7——lock语句

什么是lock语句？

lock语句是设置锁定和解除锁定的一种简单方式。

为什么使用lock语句？

在使用多线程的过程中，会出现很多难以发现的问题，比如竞态条件与死锁，为了避免这些同步问题，所以使用lock语句，当然这并不是解决同步问题的唯一方法。

lock语句的作用：

lock 关键字可确保当一个线程位于代码的临界区时，另一个线程不会进入该临界区。 如果其他线程尝试进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。

lock语句的用法：

lock 关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。 此语句的形式如下：

Object thisLock = new Object();
lock (thisLock)
{
// Critical code section.
}

lock语句的注意事项：

最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。

通常，应避免锁定 public 类型，否则实例将超出代码的控制范围。 常见的结构 lock (this)、lock (typeof (MyType)) 和 lock ("myLock") 违反此准则：

如果实例可以被公共访问，将出现 lock (this) 问题。

第一种情况：

1.同一个对象，不同线程。lock (this) 不会出现问题的例子

[b]class MyMainClass
     {
privatestaticreadonlyobject lockHelper =newobject();
privatestaticint num =0;  //记录不同线程操作的次数privateint count =0;       //记录每个对象执行次数staticvoid 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();
         }
publicvoid DoSomething()
         {
       //此处可以用this，或者也可以用lockHelperlock (this)
             {
while (num <100)
                 {
                     num++;
                     Console.WriteLine("{0} add value: {1}", Thread.CurrentThread.Name, num);
                     count++;
                 }
             }
         }
     }

[/b] 2.不同对象，不同线程。lock (this) 会出现问题的例子

[b]class MyMainClass
{
privatestaticreadonlyobject lockHelper =newobject();
privatestaticint num =0;  //记录不同线程操作的次数privateint count =0;       //记录每个对象执行次数staticvoid 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();

}

publicvoid DoSomething()
{
       //lock (this)
//此处只可以用lockHelper,若用this则锁不住lock (lockHelper)
{
while (num <100)
{
num++;
Console.WriteLine("{0} add value: {1}", Thread.CurrentThread.Name, num);
count++;
}
}

}
}

[/b]

第二种情况：如果一个类是公有的时，应该避免在基方法或属性中使用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类型的引用都有可能导致死锁。