并发编程 - 线程同步（七）之互斥锁Monitor

news/2025/2/13 15:58:29/文章来源:https://www.cnblogs.com/hugogoos/p/18713781

通过前面对锁lock的基本使用以及注意事项的学习，相信大家对锁的同步机制有了大致了解，今天我们将继续学习——互斥锁Monitor。

lock是C#语言中的关键字，是语法糖，lock语句最终会由C#编译器解析成Monitor类实现相关语句。

例如以下lock语句：

lock (obj)
{//同步代码块
}

最终会被解析成以下代码：

Monitor.Enter(obj);
try
{//同步代码块
}
finally
{Monitor.Exit(obj);
}

lock关键字简洁且易于使用，而Monitor类则功能强大，能够提供比lock关键字更细粒度、更灵活的控制以及更多的功能。

因为lock关键字是Monitor类的语法糖，因此lock关键字面临的问题，Monitor类同样也会面临。当然也会存在一些Monitor类特有的问题。

下面我们一起详细学习Monitor类的注意事项以及实现一个简单的生产者-消费者模式示例代码。

01、避免锁定值类型

这是因为 Monitor.Enter方法的参数为Object类型，这就导致如果传递值类型会导致值类型被装箱，进而导致线程在已装箱的对象上获取锁，最终线程每次调用Monitor.Enter方法都在一个完全不同的对象上获取锁，导致锁失效，无法实现线程同步。

看看下面这个代码示例：

public class LockValueTypeExample
{private static readonly int _lock = 88;public void Method1(){try{Monitor.Enter(_lock);var threadId = Thread.CurrentThread.ManagedThreadId;Console.WriteLine($"线程 {threadId} 通过 lock(值类型) 锁进入 Method1");Console.WriteLine($"进入时间 {DateTime.Now:HH:mm:ss}");Console.WriteLine($"开始休眠 5 秒");Console.WriteLine($"------------------------------------");Thread.Sleep(5000);}finally{Console.WriteLine($"开始释放锁 {DateTime.Now:HH:mm:ss}");Monitor.Exit(_lock);Console.WriteLine($"完成锁释放 {DateTime.Now:HH:mm:ss}");}}
}
public static void LockValueTypeRun()
{var example = new LockValueTypeExample();var thread1 = new Thread(example.Method1);thread1.Start();
}

看看执行结果：

可以发现在释放锁的时候抛出异常，大致意思是：“对象同步方法在未同步的代码块中被调用。”，这就是因为锁定的地方和释放的地方锁已经不一样了。

02、小心try/finally

如上面的例子，Monitor.Enter方法是写在try块中，试想一下：如果在Monitor.Enter方法之前抛出了异常会怎样异常？看下面这段代码：

public class LockBeforeExceptionExample
{private static readonly object _lock = new object();public void Method1(){try{if (new Random().Next(2) == 1){Console.WriteLine($"在调用Monitor.Enter前发生异常");throw new Exception("在调用Monitor.Enter前发生异常");}Monitor.Enter(_lock);}catch (Exception ex){Console.WriteLine($"捕捉到异常：{ex.Message}");}finally{Console.WriteLine($"开始释放锁 {DateTime.Now:HH:mm:ss}");Monitor.Exit(_lock);Console.WriteLine($"完成锁释放 {DateTime.Now:HH:mm:ss}");}}
}
public static void LockBeforeExceptionRun()
{var example = new LockBeforeExceptionExample();var thread1 = new Thread(example.Method1);thread1.Start();
}

上面代码是在调用Monitor.Enter方法前随机抛出异常，当发生异常后，可以在释放锁的时候和锁定值类型报了同样的错误，执行结果如下：

这是因为还没有执行锁定就抛出异常，导致释放一个没有锁定的锁。

那要如何解决这个问题呢？Monitor类已经考虑到了这种情况，并给出了解决办法——使用Monitor.Enter的第二个参数lockTaken，当获取锁定成功则更改lockTaken为true。如此在finally的时候只需要判断lockTaken即可决定是否需要执行释放锁操作，具体代码如下：

public class LockSolveBeforeExceptionExample
{private static readonly object _lock = new object();public void Method1(){var lockTaken = false;try{if (new Random().Next(2) == 1){Console.WriteLine($"在调用Monitor.Enter前发生异常");throw new Exception("在调用Monitor.Enter前发生异常");}Monitor.Enter(_lock,ref lockTaken);}catch (Exception ex){Console.WriteLine($"捕捉到异常：{ex.Message}");}finally{if (lockTaken){Console.WriteLine($"开始释放锁 {DateTime.Now:HH:mm:ss}");Monitor.Exit(_lock);Console.WriteLine($"完成锁释放 {DateTime.Now:HH:mm:ss}");}else{Console.WriteLine($"未执行锁定，无需释放锁");}}}
}
public static void LockSolveBeforeExceptionRun()
{var example = new LockSolveBeforeExceptionExample();var thread1 = new Thread(example.Method1);thread1.Start();
}

执行结果如下：

03、善用TryEnter

我们知道使用锁应当避免长时间持有锁，长时间持有锁会阻塞其他线程，影响性能。我们可以通过Monitor.TryEnter指定超时时间，可以看看下面示例代码：

public class LockTryEnterExample
{private static readonly object _lock = new object();public void Method1(){try{Monitor.Enter(_lock);Console.WriteLine($"Method1 | 获取锁成功，并锁定 5 秒");Thread.Sleep(5000);}finally{Monitor.Exit(_lock);}}public void Method2(){Console.WriteLine($"Method2 | 尝试获取锁");if (Monitor.TryEnter(_lock, 3000)){try{}finally{}}else{Console.WriteLine($"Method2 | 3 秒内未获取到锁，自动退出锁");}}public void Method3(){Console.WriteLine($"Method3 | 尝试获取锁");if (Monitor.TryEnter(_lock, 7000)){try{Console.WriteLine($"Method3 | 7 秒内获取到锁");}finally{Console.WriteLine($"Method3 |开始释放锁");Monitor.Exit(_lock);Console.WriteLine($"Method3 |完成锁释放");}}else{Console.WriteLine($"Method3 | 7 秒内未获取到锁，自动退出锁");}}
}
public static void LockTryEnterRun()
{var example = new LockTryEnterExample();var thread1 = new Thread(example.Method1);var thread2 = new Thread(example.Method2);var thread3 = new Thread(example.Method3);thread1.Start();thread2.Start();thread3.Start();
}

执行结果如下：

可以发现当Method1锁定5秒后，Method2尝试3秒内获取锁，结果并未获取到自动退出；然后Method3尝试7秒内获取锁，结果获取到锁并正确释放锁。

04、实现生产者-消费者模式

除了上面介绍的方法，Monitor类还有Wait、Pulse、PulseAll等方法。

Wait： 该方法用于将当前线程放入等待队列，直到收到其他线程的信号通知。

Pulse： 该方法用于唤醒等待队列中的一个线程。当一个线程调用 Pulse 时，它会通知一个正在等待该对象锁的线程继续执行。

PulseAll： 该方法用于唤醒等待队列中的所有线程。

然后我们利用Monitor类的这些功能来实现一个简单的生产者-消费者模式。大致思路如下：

1.首先启动生产者线程，获取锁，然后生成数据；

2.当生产者生产的数据小于数据队列长度，则生产一条数据同时通知消费者线程进行消费，否则暂停当前线程等待消费者线程消费数据；

3.然后启动消费者线程，获取锁，然后消费数据；

4.当数据队列中有数据，则消费一条数据同时通知生产者线程可以生产数据了，否则暂停当前线程等待生产者线程生产数据；

具体代码如下：

public class LockProducerConsumerExample
{private static Queue<int> queue = new Queue<int>();private static object _lock = new object();//生产者public  void Producer(){while (true){lock (_lock){Console.ForegroundColor = ConsoleColor.Red;if (queue.Count < 3){var item = new Random().Next(100);queue.Enqueue(item);Console.WriteLine($"生产者，生产： {item}");//唤醒消费者Monitor.Pulse(_lock);  }else{//队列满时，生产者等待Console.WriteLine($"队列已满，生产者等待中……");Monitor.Wait(_lock);  }}Thread.Sleep(500);}}// 消费者public  void Consumer(){while (true){lock (_lock){Console.ForegroundColor = ConsoleColor.Blue;if (queue.Count > 0){var item = queue.Dequeue();Console.WriteLine($"消费者，消费： {item}");//唤醒生产者Monitor.Pulse(_lock);  }else{//队列空时，消费者等待Console.WriteLine($"队列已空，消费者等待中……");Monitor.Wait(_lock);  }}Thread.Sleep(10000);}}
}
public static void LockProducerConsumerRun()
{var example = new LockProducerConsumerExample();var thread1 = new Thread(example.Producer);var thread2 = new Thread(example.Consumer);thread1.Start();thread2.Start();thread1.Join();thread2.Join();
}

执行结果如下：