ToB企服应用市场:ToB评测及商务社交产业平台

标题: 并发编程 - 线程同步（六）之锁lock [打印本页]
作者: 笑看天下无敌手    时间: 2025-2-12 16:00
标题: 并发编程 - 线程同步（六）之锁lock
通过前面临Interlocked类的学习，相信大家对线程同步机制有了更深的理解，今天我们将继续需要另一种同步机制——锁lock。

lock是C#语言中的关键字，是线程同步机制的一种简单的互斥锁实现方式，它可以保证在同一时刻只有一个线程能够访问被锁定的代码块。其工作原理也很简单，就是通过lock创建一个互斥锁，当一个线程获取到此互斥锁则此线程可以进入被lock掩护的代码块，同时其他线程将被壅闭无法进入此代码块，直至第一个线程释放此互斥锁，其他线程才可以获取此互斥锁并进入代码块。

lock的利用也非常简单，语法如下：
  1. lock (obj)
  2. {
  3.     //线程不安全的代码块
  4. }
复制代码
虽然lock利用起来简单方便，但是利用方式不正确也很容易产生各种奇希奇怪的问题。
01、避免锁定this

这种利用方式会导致两个问题：
1.不可控性：lock(this)锁定的范围是整个实例，这也就意味着其他线程可以通过该实例中的其他方法访问该锁，进而形成一个实例中多个利用lock(this)的方法之前相互影响。
2.外部可见性：this表示当前实例的引用，它是公共的，因此外部代码也可以访问，这也就意味着外部代码可以通过lock(实例)访问lock(this)锁，从而使同步机制失去控制。
下面我们直接看代码：
  1. public class LockThisExample
  2. {
  3.     public void Method1()
  4.     {
  5.         lock (this)
  6.         {
  7.             var threadId = Thread.CurrentThread.ManagedThreadId;
  8.             Console.WriteLine($"线程 {threadId} 通过lock(this)锁进入 Method1");
  9.             Console.WriteLine($"进入时间 {DateTime.Now:HH:mm:ss}");
  10.             Console.WriteLine($"开始休眠 5 秒");
  11.             Console.WriteLine($"------------------------------------");
  12.             Thread.Sleep(5000);
  13.         }
  14.     }
  15.     public void Method2()
  16.     {
  17.         lock (this)
  18.         {
  19.             var threadId = Thread.CurrentThread.ManagedThreadId;
  20.             Console.WriteLine($"线程 {threadId} 通过lock(this)锁进入 Method2");
  21.             Console.WriteLine($"进入时间 {DateTime.Now:HH:mm:ss}");
  22.         }
  23.     }
  24. }
  25. public static void LockThisRun()
  26. {
  27.     var example = new LockThisExample();
  28.     var thread1 = new Thread(example.Method1);
  29.     var thread2 = new Thread(example.Method2);
  30.     var thread3 = new Thread(() =>
  31.     {
  32.         lock (example)
  33.         {
  34.             var threadId = Thread.CurrentThread.ManagedThreadId;
  35.             Console.WriteLine($"线程 {threadId} 通过lock(实例)锁进入 Method3");
  36.             Console.WriteLine($"进入时间 {DateTime.Now:HH:mm:ss}");
  37.             Console.WriteLine($"开始休眠 5 秒");
  38.             Console.WriteLine($"------------------------------------");
  39.             Thread.Sleep(5000);
  40.         }
  41.     });
  42.     thread3.Start();
  43.     thread1.Start();
  44.     thread2.Start();
  45. }
复制代码
我们看看代码执行结果：

这里例子可以很好的阐明lock(this)代理的问题，原本可以三个线程并发执行的三段代码，因为利用了同一个锁，导致三个线程只能顺序执行。其中Method1和Method2表现了同一实例内方法相互影响，Method3和Method1、Method2表现了因为相同实例导致实例内部方法和实破例部方法相互影响。
02、避免锁定公共对象

这种利用方式会导致两个问题：
1.全局影响：公共对象，特别是 public static 对象，很大概率会被多个类，乃至多个模块引用，因此锁定公共对象很可能导致全局范围内的同步，大大增长了死锁、竞争条件的产生的风险。
2.不可预测性：因为公共对象对全局可访问，因此如果其他模块锁定此公共对象，则当出现问题时将难以清除调试问题。
看下面代码：
  1. public class PublicLock
  2. {
  3.     public static readonly object Lock = new object();
  4. }
  5. public class LockPublic1Example
  6. {
  7.     public void Method1()
  8.     {
  9.         lock (PublicLock.Lock)
  10.         {
  11.             var threadId = Thread.CurrentThread.ManagedThreadId;
  12.             Console.WriteLine($"线程 {threadId} 通过 lock(公共对象) 锁进入 Public1");
  13.             Console.WriteLine($"进入时间 {DateTime.Now:HH:mm:ss}");
  14.             Console.WriteLine($"开始休眠 5 秒");
  15.             Console.WriteLine($"------------------------------------");
  16.             Thread.Sleep(5000);
  17.         }
  18.     }
  19. }
  20. public class LockPublic2Example
  21. {
  22.     public void Method1()
  23.     {
  24.         lock (PublicLock.Lock)
  25.         {
  26.             var threadId = Thread.CurrentThread.ManagedThreadId;
  27.             Console.WriteLine($"线程 {threadId} 通过 lock(公共对象) 锁进入 Public2");
  28.             Console.WriteLine($"进入时间 {DateTime.Now:HH:mm:ss}");
  29.         }
  30.     }
  31. }
  32. public static void LockPublicRun()
  33. {
  34.     var example1 = new LockPublic1Example();
  35.     var example2 = new LockPublic2Example();
  36.     var thread1 = new Thread(example1.Method1);
  37.     var thread2 = new Thread(example2.Method1);
  38.     thread1.Start();
  39.     thread2.Start();
  40. }
复制代码
在看看执行结果：

可以发现因为锁定了同一个公共对象，导致两个不同线程的不同实例，照旧产生相互争抢锁的问题。
03、避免锁定字符串

在C#中，字符串因其不可变性和字符串池的缘故原由，在整个程序中一个字符串一旦创建就不会更改，如果对其修改则产生新的字符串对象，而原字符串对象保持不变；同时如果创建两个相同内容的字符串，则它们共享同一个内存地址。
这就导致锁定字符串极其危险尤其危险，因为整个程序中任何给定字符串都只有一个实例，而在整个程序中只有锁定相同内容的字符串都会形成竞争条件。
  1. public class LockString1Example
  2. {
  3.     public void Method1()
  4.     {
  5.         lock ("abc")
  6.         {
  7.             var threadId = Thread.CurrentThread.ManagedThreadId;
  8.             Console.WriteLine($"线程 {threadId} 通过 lock(字符串) 锁进入 String1");
  9.             Console.WriteLine($"进入时间 {DateTime.Now:HH:mm:ss}");
  10.             Console.WriteLine($"开始休眠 5 秒");
  11.             Console.WriteLine($"------------------------------------");
  12.             Thread.Sleep(5000);
  13.         }
  14.     }
  15. }
  16. public class LockString2Example
  17. {
  18.     public void Method1()
  19.     {
  20.         lock ("abc")
  21.         {
  22.             var threadId = Thread.CurrentThread.ManagedThreadId;
  23.             Console.WriteLine($"线程 {threadId} 通过 lock(字符串) 锁进入 String2");
  24.             Console.WriteLine($"进入时间 {DateTime.Now:HH:mm:ss}");
  25.         }
  26.     }
  27. }
  28. public static void LockStringRun()
  29. {
  30.     var example1 = new LockString1Example();
  31.     var example2 = new LockString2Example();
  32.     var thread1 = new Thread(example1.Method1);
  33.     var thread2 = new Thread(example2.Method1);
  34.     thread1.Start();
  35.     thread2.Start();
  36. }
复制代码
我们看看执行结果：

可以发现虽然在两个类中分别利用了两个字符串“abc”,但对于整个程序来说它们都指向了同一个实例，因此共用了一把锁。
04、小心锁定非readonly对象

这是因为如果锁对象为非只读对象，就可能发生某个lock代码块中修改锁对象，从而导致
锁对象变更，进而使得其他线程可以畅通无阻的进入该代码块。
如下示例：
  1. public class LockNotReadonlyExample
  2. {
  3.     private object _lock = new object();
  4.     public void Method1()
  5.     {
  6.         lock (_lock)
  7.         {
  8.             _lock = new object();
  9.             var threadId = Thread.CurrentThread.ManagedThreadId;
  10.             Console.WriteLine($"线程 {threadId} 进入 Method1 , 时间 {DateTime.Now:HH:mm:ss}");
  11.             Console.WriteLine($"------------------------------------");
  12.             Thread.Sleep(5000);
  13.         }
  14.     }
  15. }
  16. public static void LockNotReadonlyRun()
  17. {
  18.     var example = new LockNotReadonlyExample();
  19.     var thread1 = new Thread(example.Method1);
  20.     var thread2 = new Thread(example.Method1);
  21.     var thread3 = new Thread(example.Method1);
  22.     thread1.Start();
  23.     thread2.Start();
  24.     thread3.Start();
  25. }
复制代码
再来看执行结果：

可以发现三个线程几乎同时进入，lock根本就没有起到锁的作用。
05、小心锁定静态对象

对于是否需要锁定静态对象取决于你的需求。
1.如果要在静态方法中利用lock时，则锁定的对象也必须要是静态对象。
2.如果希望类的每个实例都有独立的锁对象，则锁定非静态对象。
3.如果希望类的所有实例共享同一个锁，则锁定静态对象。
代码示例如下：
  1. public class LockStaticExample
  2. {
  3.     //这是一个实例字段，意味着类的每个实例都会有一个独立的锁对象。
  4.     //如果你希望类的每个实例有自己独立的锁来控制并发访问，这种方式更合适。
  5.     private readonly object _lock1 = new object();
  6.     //这是一个静态字段，意味着类的所有实例共享同一个锁对象。
  7.     //如果你希望类的所有实例都共享同一个锁来同步对某个静态资源访问，这种方式更合适。
  8.     private static readonly object _lock2 = new object();
  9.     public void Method1()
  10.     {
  11.         lock (_lock1)
  12.         {
  13.             // 临界区代码
  14.         }
  15.     }
  16.     public void Method2()
  17.     {
  18.         lock (_lock2)
  19.         {
  20.             // 临界区代码
  21.         }
  22.     }
  23.     public static void Method3()
  24.     {
  25.         lock (_lock2)
  26.         {
  27.             // 临界区代码
  28.         }
  29.     }
  30. }
复制代码
这是因为静态字段是所有实例共享的，其内存地址在整个程序的生命周期内是唯一的，所有实例访问同一个内存地址，因此锁定静态对象时要特别小心。
注：测试方法代码以及示例源码都已经上传至代码库，有兴趣的可以看看。https://gitee.com/hugogoos/Planner

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4