C#使用Monitor类、Lock和Mutex类进行多线程同步

系统管理员 2022-04-10 08:43 156阅读 0赞

在多线程中，为了使数据保持一致性必须要对数据或是访问数据的函数加锁，在数据库中这是很常见的，但是在程序中由于大部分都是单线程的程序，所以没有加锁的必要，但是在多线程中，为了保持数据的同步，一定要加锁，好在Framework中已经为我们提供了三个加锁的机制，分别是Monitor类、Lock关键字和Mutex类。  
其中Lock关键词用法比较简单，Monitor类和Lock的用法差不多。这两个都是锁定数据或是锁定被调用的函数。而Mutex则多用于锁定多线程间的同步调用。简单的说，Monitor和Lock多用于锁定被调用端，而Mutex则多用锁定调用端。  
例如下面程序：由于这种程序都是毫秒级的，所以运行下面的程序可能在不同的机器上有不同的结果，在同一台机器上不同时刻运行也有不同的结果，我的测试环境为vs2005, windowsXp , CPU3.0 , 1 G monery。  
程序中有两个线程thread1、thread2和一个TestFunc函数，TestFunc会打印出调用它的线程名和调用的时间(mm级的)，两个线程分别以30mm和100mm来调用TestFunc这个函数。TestFunc执行的时间为50mm。程序如下：  
using System;  
using System.Collections.Generic;  
using System.Text;  
using System.Threading;  
namespace MonitorLockMutex  
\{  
class Program  
\{  
\#region variable  
Thread thread1 = null;  
Thread thread2 = null;  
Mutex mutex = null;  
\#endregion  
static void Main(string\[\] args)  
\{  
Program p = new Program();  
p.RunThread();  
Console.ReadLine();  
\}  
public Program()  
\{  
mutex = new Mutex();  
thread1 = new Thread(new ThreadStart(thread1Func));  
thread2 = new Thread(new ThreadStart(thread2Func));  
\}  
public void RunThread()  
\{  
thread1.Start();  
thread2.Start();  
\}  
private void thread1Func()  
\{  
for (int count = 0; count < 10; count++)  
\{  
TestFunc("Thread1 have run " + count.ToString() + " times");  
Thread.Sleep(30);  
\}  
\}  
private void thread2Func()  
\{  
for (int count = 0; count < 10; count++)  
\{  
TestFunc("Thread2 have run " + count.ToString() + " times");  
Thread.Sleep(100);  
\}  
\}  
private void TestFunc(string str)  
\{  
Console.WriteLine("\{0\} \{1\}", str, System.DateTime.Now.Millisecond.ToString());  
Thread.Sleep(50);  
\}  
\}  
\}  
运行结果如下：

可以看出如果不加锁的话，这两个线程基本上是按照各自的时间间隔+TestFunc的执行时间(50mm)对TestFunc函数进行读取。因为线程在开始时需要分配内存，所以第0次的调用不准确，从第1~9次的调用可以看出，thread1的执行间隔约是80mm，thread2的执行间隔约是150mm。  
现在将TestFunc修改如下：  
private void TestFunc(string str)  
\{  
lock (this)  
\{  
Console.WriteLine("\{0\} \{1\}", str, System.DateTime.Now.Millisecond.ToString());  
Thread.Sleep(50);  
\}  
\}  
或者是用Monitor也是一样的，如下：  
private void TestFunc(string str)  
\{  
Monitor.Enter(this);  
Console.WriteLine("\{0\} \{1\}", str, System.DateTime.Now.Millisecond.ToString());  
Thread.Sleep(50);  
Monitor.Exit(this);  
\}  
其中Enter和Exit都是Monitor中的静态方法。  
运行Lock结果如下：

让我们分析一下结果，同样从第1次开始。相同线程间的调用时间间隔为线程执行时间+TestFunc调用时间，不同线程间的调用时间间隔为TestFunc调用时间。例如：连续两次调用thread1之间的时间间隔约为30+50=80;连续两次调用thread2之间的时间间隔约为100+50=150mm。调用thread1和thread2之间的时间间隔为50mm。因为TestFunc被lock住了，所以一个thread调用TestFunc后，当其它的线程也同时调用TestFunc时，后来的线程即进被排到等待队列中等待，直到拥有访问权的线程释放这个资源为止。  
这就是锁定被调用函数的特性，即只能保证每次被一个线程调用，线程优先级高的调用的次数就多，低的就少，这就是所谓的强占式。  
下面让我们看看Mutex类的使用方法，以及与Monitor和Lock的区别。  
将代码修改如下：  
private void thread1Func()  
\{  
for (int count = 0; count < 10; count++)  
\{  
mutex.WaitOne();  
TestFunc("Thread1 have run " + count.ToString() + " times");  
mutex.ReleaseMutex();  
\}  
\}  
private void thread2Func()  
\{  
for (int count = 0; count < 10; count++)  
\{  
mutex.WaitOne();  
TestFunc("Thread2 have run " + count.ToString() + " times");  
mutex.ReleaseMutex();  
\}  
\}  
private void TestFunc(string str)  
\{  
Console.WriteLine("\{0\} \{1\}", str, System.DateTime.Now.Millisecond.ToString());  
Thread.Sleep(50);  
\}  
运行结果如下：

可以看出，Mutex只能互斥线程间的调用，但是不能互斥本线程的重复调用，即thread1中waitOne()只对thread2中的waitOne()起到互斥的作用，但是thread1并不受本wainOne()的影响，可以调用多次，只是在调用结束后调用相同次数的ReleaseMutex()就可以了。  
那么如何使线程按照调用顺序来依次执行呢？其实把lock和Mutex结合起来使用就可以了，改代码如下：  
private void thread1Func()  
\{  
for (int count = 0; count < 10; count++)  
\{  
lock (this)  
\{  
mutex.WaitOne();  
TestFunc("Thread1 have run " + count.ToString() + " times");  
mutex.ReleaseMutex();  
\}  
\}  
\}  
private void thread2Func()  
\{  
for (int count = 0; count < 10; count++)  
\{  
lock (this)  
\{  
mutex.WaitOne();  
TestFunc("Thread2 have run " + count.ToString() + " times");  
mutex.ReleaseMutex();  
\}  
\}  
\}

发表评论取消回复

表情：

评论列表（有 0 条评论，156人围观）

还没有评论，来说两句吧...

相关阅读

相关 Java多线程同步工具类：Lock和Condition实例

在Java中，我们通常使用`java.util.concurrent.locks.Lock`接口来实现线程的同步。而`java.util.concurrent.locks.Co

不念不忘少年蓝@/ 2024年10月07日 05:36/ 0 赞/ 66 阅读

相关 C++11多线程之mutex

概述 `mutex` 类是能用于保护共享数据免受从多个线程同时访问的同步原语。调用方线程从它成功调用 lock 或 try\_lock 开始，到它调用 unlo

Love The Way You Lie/ 2022年11月22日 00:05/ 0 赞/ 126 阅读

相关 vb.net 教程 6-17 使用Monitor类实现线程的同步

版权声明：本文为博主原创文章，转载请在显著位置标明本文出处以及作者网名，未经作者允许不得用于商业目的。如上一节《vb.net 教程 6-16 使用SyncLock语句实现线

拼搏现实的明天。/ 2022年09月11日 03:27/ 0 赞/ 78 阅读

相关 vb.net 教程 6-17 使用Monitor类实现线程的同步

版权声明：本文为博主原创文章，转载请在显著位置标明本文出处以及作者网名，未经作者允许不得用于商业目的。先看以下代码： Sub sample12()

痛定思痛。/ 2022年09月11日 03:27/ 0 赞/ 103 阅读

相关 VB.NET中使用监控类进行线程同步

简介在进行多线程开发时，线程间同步调用同样的函数是非常重要的。考虑你有一个写文件的函数，如果多个线程同时都调用这个函数，在一个线程完成操作之前，再调用肯定会抛出异常。为避

àì夳堔傛蜴生んèń/ 2022年08月23日 08:11/ 0 赞/ 81 阅读

相关多线程同步集合类

多线程并发在操作传统集合的时候，有可能出现死循环（带有while循环的代码）或者抛异常（在使用迭代器的时候），因为需要专门的多线程集合保证集合安全。 1,Concurren

r囧r小猫/ 2022年07月13日 12:27/ 0 赞/ 184 阅读

相关 C# 多线程(lock,Monitor,Mutex,同步事件和等待句柄)

原文地址：http://www.cnblogs.com/SkySoot/archive/2012/04/02/2430295.html 本篇从 Monitor，Mute

爱被打了一巴掌/ 2022年06月09日 14:18/ 0 赞/ 174 阅读

相关 C#中的lock、Monitor、Mutex学习笔记

线程：线程是进程的独立执行单元，每一个进程都有一个主线程，除了主线程可以包含其他的线程。多线程的意义：多线程有助于改善程序的总体响应性，提高CPU的效率。多线程的应用程

红太狼/ 2022年06月09日 13:51/ 0 赞/ 183 阅读

相关 C#使用Monitor类、Lock和Mutex类进行多线程同步

在多线程中，为了使数据保持一致性必须要对数据或是访问数据的函数加锁，在数据库中这是很常见的，但是在程序中由于大部分都是单线程的程序，所以没有加锁的必要，但是在多线程中，为了保持

系统管理员/ 2022年04月10日 08:43/ 0 赞/ 157 阅读

相关 C# 线程同步技术（三）之 Monitor 和Lock

今天我们总结一下 C\线程同步中的 Monitor 类和 Lock 关键字进行一下总结。首先来看看他们有什么异同（相信对此熟悉的朋友们都很清楚）： <table>

悠悠/ 2022年01月09日 08:13/ 0 赞/ 192 阅读