线程学习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) 不会出现问题的例子

 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++; } } } }     

       2.不同对象，不同线程。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(); 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类型的引用都有可能导致死锁。