通过实例学C#之Mutex（互斥锁）类

最新推荐文章于 2024-04-23 12:24:53 发布
最新推荐文章于 2024-04-23 12:24:53 发布
阅读量1.3k 收藏 19
点赞数 25
分类专栏： C# 文章标签： c# 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lgh65200/article/details/137678440
版权

作用

        当线程A需要对数据1进行判断，然后根据判断结果进行后续操作时，如果线程B，此刻也对数据1进行操作，可能会产生意向不到的错误。

        例如，设备J对工件X的温度进行判断，得知工件的温度满足条件后，可以进行下一个工艺操作，此时，如果另一个设备K对工件X进行降温操作，那么，工件X的温度就不满足执行后续制作工艺条件，这时候，如果强行进行后续操作，可能会产生次品。

        那么，中间出现问题的步骤是在哪里呢？很明显，当设备J对工件X进行温度判断后，直到后面工艺执行完，按理说都不能让其他设备对工件X进行温度上的控制。而互斥锁，就可以把工件X锁住，此时，所有其他设备都无法改变其温度，等执行完后续工艺后，再解锁，然后其他设备就可以对工件X的温度进行控制了。

构造函数

Mutex()

        创建一个Mutex互斥锁对象，且当前线程对互斥锁无所有权，如果需要获取对互斥锁的所有权，需要使用WaitOne()方法。

不使用互斥锁实例：

static int count = 0;        //用于计数

static void Main(string[] args)
{
    Thread t1 = new Thread(ShowValue);
    Thread t2= new Thread(ChangeValue);

    t1.Start();     //线程1启动
    t2.Start();     //线程2启动

    Console.WriteLine("主线程结束，请按任意键退出");
    Console.ReadKey();
}

//线程1方法
static void ShowValue()
{
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine("t1：count值为:" + count.ToString());
        Thread.Sleep(1000);
    }
}

//线程2方法
static void ChangeValue()
{
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine("-------t2--------对count进行+1操作");
        count++;
        Console.WriteLine("-------t2--------count值为:" + count.ToString());
        Thread.Sleep(1000);
    }
}

运行结果：

主线程结束，请按任意键退出
t1：count值为:0
-------t2--------对count进行+1操作
-------t2--------count值为:1
-------t2--------对count进行+1操作
-------t2--------count值为:2
t1：count值为:1
t1：count值为:2
-------t2--------对count进行+1操作
-------t2--------count值为:3
-------t2--------对count进行+1操作
-------t2--------count值为:4
t1：count值为:3
-------t2--------对count进行+1操作
-------t2--------count值为:5
t1：count值为:4

可以看到，子线程的操作对主线程的读数有影响。

如果希望主线程执行过程中，count保持不变，就需要使用互斥锁Mutex对象。实例如下：

static int count = 0;        //用于计数
static Mutex mutex = new Mutex();      //创建互斥锁实例
static void Main(string[] args)
{
    Thread t1 = new Thread(ShowValue);
    Thread t2= new Thread(ChangeValue);
    
    t1.Start();     //线程1启动
    t2.Start();     //线程2启动

    Console.WriteLine("主线程结束，请按任意键退出");
    Console.ReadKey();
}

//线程1方法
static void ShowValue()
{
    mutex.WaitOne();        //如果互斥锁的所有权被释放，那么线程1获取互斥锁的所有权
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine("t1：count值为:" + count.ToString());
        Thread.Sleep(1000);
    }
    mutex.ReleaseMutex();        //线程1释放互斥锁
}

//线程2方法
 static void ChangeValue()
 {
     mutex.WaitOne();        //如果互斥锁的所有权被释放，那么线程2获取互斥锁的所有权
     for (int i = 0; i < 5; i++)
     {
         Console.WriteLine("-------t2--------对count进行+1操作");
         count++;
         Console.WriteLine("-------t2--------count值为:" + count.ToString());
         Thread.Sleep(1000);
     }
     mutex.ReleaseMutex();        //线程2释放互斥锁
 }

运行结果：

主线程结束，请按任意键退出
t1：count值为:0
t1：count值为:0
t1：count值为:0
t1：count值为:0
t1：count值为:0
-------t2--------对count进行+1操作
-------t2--------count值为:1
-------t2--------对count进行+1操作
-------t2--------count值为:2
-------t2--------对count进行+1操作
-------t2--------count值为:3
-------t2--------对count进行+1操作
-------t2--------count值为:4
-------t2--------对count进行+1操作
-------t2--------count值为:5

可以看到，由于T1先启动，所以在使用mutex.WaitOne（）方法后，T1获得互斥锁mutex的所有权，这时候，T2的mutex.WaitOne（）代码返回false，所以线程阻塞，必须等T1调用mutex.ReleaseMutex()后才能继续执行。

子线程的代码不变，如果我们更改一下T1,T2的启动顺序：

 static void Main(string[] args)
 {
     Thread t2= new Thread(ChangeValue);
     Thread t1 = new Thread(ShowValue);

     t2.Start();     //线程2启动
     t1.Start();     //线程1启动

     Console.WriteLine("主线程结束，请按任意键退出");
     Console.ReadKey();
 }

返回结果：

主线程结束，请按任意键退出
-------t2--------对count进行+1操作
-------t2--------count值为:1
-------t2--------对count进行+1操作
-------t2--------count值为:2
-------t2--------对count进行+1操作
-------t2--------count值为:3
-------t2--------对count进行+1操作
-------t2--------count值为:4
-------t2--------对count进行+1操作
-------t2--------count值为:5
t1：count值为:5
t1：count值为:5
t1：count值为:5
t1：count值为:5
t1：count值为:5

可以看到，程序会先执行T2的代码段，然后在T2释放互斥锁以后，T1接着执行。

另外，互斥锁针对的是WaitOne（）以及ReleaseMutex（）之间的代码，而不是整个线程，Main（）函数不变，我们看看下面实例：

static void ChangeValue()
{
    Console.WriteLine("T2在互斥锁以外的代码");
    mutex.WaitOne();
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine("-------t2--------对count进行+1操作");
        count++;
        Console.WriteLine("-------t2--------count值为:" + count.ToString());
        Thread.Sleep(1000);
    }
    mutex.ReleaseMutex();
}

static void ShowValue()
{
    Console.WriteLine("T1在互斥锁以外的代码");
    mutex.WaitOne();
    for (int i = 0; i < 5; i++)
    {
        Console.WriteLine("t1：count值为:" + count.ToString());
        Thread.Sleep(1000);
    }
    mutex.ReleaseMutex();
}

运行结果：

主线程结束，请按任意键退出
T1在互斥锁以外的代码
T2在互斥锁以外的代码
t1：count值为:0
t1：count值为:0
t1：count值为:0
t1：count值为:0
t1：count值为:0
-------t2--------对count进行+1操作
-------t2--------count值为:1
-------t2--------对count进行+1操作
-------t2--------count值为:2
-------t2--------对count进行+1操作
-------t2--------count值为:3
-------t2--------对count进行+1操作
-------t2--------count值为:4
-------t2--------对count进行+1操作
-------t2--------count值为:5

可以看到，在互斥锁以外的代码，是不受互斥锁的阻塞影响的。

Mutex(bool)

如果创建实例时，填入一个bool参数，那么表示，在创建该互斥锁的同时，会相应控制互斥锁的所有权，如果参数为True，表示创建互斥锁的线程，具有互斥锁的所有权，如果它不使用ReleaseMux（）释放互斥锁的所有权，那么其他使用互斥锁的线程，将一直被阻塞。实例如下

static int count = 0;        //用于计数
static Mutex mutex = new Mutex(true);      //创建互斥锁实例并获取互斥锁所有权
static void Main(string[] args)
{
    Thread t2= new Thread(ChangeValue);
    Thread t1 = new Thread(ShowValue);

    
    t2.Start();     //线程2启动
    t1.Start();     //线程1启动

    Console.WriteLine("主线程结束，请按任意键退出");
    Console.ReadKey();
}

线程调用方法不变，运行结果：

主线程结束，请按任意键退出

由于主线程在创建时，获取了互斥锁的所有权，而主线程一直没有调用ReleaseMutex（）方法，所以，同样使用了互斥锁的T1,T2一直无法执行。

这时候，如果我们在主线程的某一时刻释放了互斥锁：
 

static int count = 0;        //用于计数
static Mutex mutex = new Mutex(true);      //创建互斥锁实例并获取互斥锁所有权
static void Main(string[] args)
{
    Thread t2= new Thread(ChangeValue);
    Thread t1 = new Thread(ShowValue);

    
    t2.Start();     //线程2启动
    t1.Start();     //线程1启动

    Console.WriteLine("主线程延迟3秒释放互斥锁");
    Thread.Sleep(3000);
    mutex.ReleaseMutex();

    Console.WriteLine("主线程结束，请按任意键退出");
    Console.ReadKey();
}

运行结果：

主线程延迟3秒释放互斥锁
主线程结束，请按任意键退出
-------t2--------对count进行+1操作
-------t2--------count值为:1
-------t2--------对count进行+1操作
-------t2--------count值为:2
-------t2--------对count进行+1操作
-------t2--------count值为:3
-------t2--------对count进行+1操作
-------t2--------count值为:4
-------t2--------对count进行+1操作
-------t2--------count值为:5
t1：count值为:5
t1：count值为:5
t1：count值为:5
t1：count值为:5
t1：count值为:5

可以看到，主线程释放互斥锁以后，两个分线程都能正常运行。

所以，Mutex mutex=Mutex（True）等价于 Mutex mutex=Mutex（）+ mutex.WaitOne（）。

常用方法

WaitOne（）

        获取互斥锁的所有权，如果互斥锁当前处于释放状态，执行WaitOne（）后返回true，当前线程获取互斥锁所有权。如果互斥锁被其他线程占有，那么当前线程执行WaitOne（）后返回false，获取互斥锁所有权失败，要继续等待拥有互斥锁的线程释放互斥锁所有权。

ReleaseMutex()

        释放互斥锁的所有权

小满学编程
关注
  • 25
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C#中Mutex对象用法分析
12-25
本文实例讲述了C#中Mutex对象用法。分享给大家供大家参考，具体如下： C#语言有很多值得学习的地方，这里我们就来介绍C# Mutex对象，包括介绍控制好多个线程相互之间的联系等方面。 如何控制好多个线程相互之间的联系，不产生冲突和重复，这需要用到互斥对象，即：System.Threading 命名空间中的 Mutex 类。 我们可以把Mutex看作一个出租车，乘客看作线程。乘客首先等车，然后上车，最后下车。当一个乘客在车上时，其他乘客就只有等他下车以后才可以上车。而线程与C# Mutex对象的关系也正是如此，线程使用Mutex.WaitOne()方法等待C# Mutex对象被释放，如果它等
C#_进程单例模式.秒懂Mutex
wnw1234的博客
08-29 216
可以定义调用线程是否具有互斥性，程序创建者拥有控制权，相反只能引用程序。参数1：如果是程序创建者，就获得控制权。参数2：名称，可使用GUID生成。参数3：out 返回值；true 是程序创建者，false 不是程序创建者。
C#互斥锁Mutex的用法
csdn2990的博客
03-15 2485
C#中Mutex是互斥锁，位于System.Threading 命名空间中。 顾名思义，它是一个互斥的对象，同一时间只有一个线程可以拥有它，该类还可用于进程间同步的同步基元。 如果当前有一个线程拥有它，在没有释放之前，其它线程是没有权利拥有它的。我们可以把Mutex看作洗手间，上厕所的人看作线程；上厕所的人先进洗手间，拥有使用权，上完厕所之后出来，把洗手间释放，其他人才可以使用。 线程使用Mutex.WaitOne()方法等待C# Mutex对象被释放，如果它等待的C# Mutex对象被释放了，它就自动拥有
C#多线程同步实战：全面掌握Mutex、Semaphore与Monitor，代码示例与深度解析
最新发布
java专栏
04-23 796
本文从零开始，详细介绍了C#中的多线程同步机制——Mutex、Semaphore与Monitor，包括它们的创建、使用方法，以及应用场景。通过这些内容，您应已全面理解如何在C#中使用这些同步原语来解决多线程编程中的同步问题，掌握了在不同场景下选择合适同步机制的方法。C#提供了多种同步原语，如Mutex、Semaphore与Monitor，用于实现线程间的同步与互斥。注释：创建一个允许最多3个线程同时执行的Semaphore，线程在进入并发受限区域前请求资源，执行完毕后释放资源。：创建Mutex实例，使用。
c#Mutex的用法总结
qq_34059233的博客
05-13 6068
1、Mutex在线程中的使用； 2、Mutex在进程中的使用；
C# 多线程四：互斥量Mutex的简单理解与运用
SmillCool的博客
10-08 3886
Mutex 互斥 多线程 线程同步
C#中的互斥锁
w909252427的博客
03-22 1271
在这个示例代码中，DoWork方法是一个需要互斥锁保护的任务，在进入这个方法之前，线程需要调用mutex.WaitOne方法等待互斥锁的释放，当任务完成后，需要调用mutex.ReleaseMutex方法释放持有的互斥锁。使用Mutex类可以大大提高数据的正确性和代码的健壮性，但是过多的互斥锁使用也会影响程序的性能。互斥锁是一种常用的线程同步机制，用于保证在任意时刻只有一个线程在访问共享资源。Mutex类提供的WaitOne和ReleaseMutex方法可分别用于等待互斥锁的释放和释放持有的互斥锁。
线程同步之互斥量mutex的使用
betsyfeng的专栏
05-08 1282
<br />什么是Mutex<br />　　“mutex”是术语“互相排斥（mutually exclusive）”的简写形式，也就是互斥量。互斥量跟临界区中提到的Monitor很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂，因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的
C#多线程中如何运用互斥锁Mutex
08-30
主要为大家详细介绍了C#多线程中如何运用互斥锁Mutex，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c# mutex互斥量的深入解析
12-31
互斥锁（Mutex） 互斥锁是一个互斥的同步对象，意味着同一时间有且仅有一个线程可以获取它。 互斥锁可适用于一个共享资源每次只能被一个线程访问的情况  函数： //创建一个处于未获取状态的互斥锁 Public Mutex（）...
C#使用Mutex简单实现程序单实例运行的方法
09-03
主要介绍了C#使用Mutex简单实现程序单实例运行的方法,涉及C#实现单实例程序运行的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
C# 锁—Mutex简介
weixin_47249500的博客
04-12 1575
Mutex对象是一种锁资源，线程之间可以竞争锁资源，但同一时刻只有一条线程能成功占据锁资源。占据到锁资源的线程可以顺利执行，其余的线程阻塞。占据锁资源的线程释放锁资源后，其余的线程继续竞争，竞争成功的线程解除阻塞，以此保证线程间的同步。注意：竞争同一个Mutex实例对象的线程之间是竞争关系。竞争不同Mutex实例对象的线程之间不存在竞争关系。
C#中Mutex的用法
beautifull001的博客
02-27 5865
C#中Mutex是互斥锁，位于System.Threading 命名空间中。 顾名思义，它是一个互斥的对象，同一时间只有一个线程可以拥有它，该类还可用于进程间同步的同步基元。 如果当前有一个线程拥有它，在没有释放之前，其它线程是没有权利拥有它的。我们可以把Mutex看作洗手间，上厕所的人看作线程；上厕所的人先进洗手间，拥有使用权，上完厕所之后出来，把洗手间释放，其他人才可以使用。 线程使用M...
C#（五十四）之线程Mutex互斥
camellia的博客
07-06 644
在声明mutex对象时，在构造函数中传入该线程的名字，两个应用线程的名字相同，我们就认为该mutex线程时系统互斥线程。利用所需的安全访问权限，打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。使用可指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称。使用可指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称。打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。用一个指示调用线程是否应拥有互斥体的初始所属权的布尔值。
C#之：线程同步 Mutex类
C++++ ++
08-26 1905
Mutex（互斥锁）： Mutex： 命名空间:System.Threading 一个同步基元，也可用于进程间同步。是.NET Framework 中提供跨多个线程，或多个进程同步访问的一个类。它非常类似于Monitor类，他们都只有一个线程能拥有锁定，只有一个线程能获得互斥锁，访问受互斥保护的同步代码区域。 在 Mutex 类的构造函数中，可以指定互斥是否最初应有主线程拥有，定义互斥的名称，获得...
C# 互斥锁（lock）
标准都是留给不爱的人，爱的本质是自由意志的沉沦
07-14 1078
关键字用于声明一个代码块，在该代码块中对共享资源的访问会被互斥锁保护起来，确保同一时间只有一个线程可以执行该代码块。关键字会自动处理锁的获取和释放，并且保证在锁被释放之前，其他线程无法进入被保护的代码块。关键字时，确保锁的范围仅包含必要的代码，避免锁的持有时间过长以及锁的粒度过大，从而避免潜在的性能问题。另外，为了保护共享资源的一致性，建议在所有访问和修改共享资源的代码块中都使用相同的。关键字，我们可以轻松地实现互斥锁，保护共享资源的访问，从而避免并发访问带来的问题。的锁，其他线程将在此处等待。
C#使用Mutex实现单例应用程序
月亮哥的专栏
01-03 375
C#使用Mutex实现单例应用程序
C# 互斥锁
qq_57751363的博客
03-27 388
thread2 在遇到第一个sheep时被睡眠了，转到thread1中执行，也同样被睡眠，此时a的值取到101，然后0.5秒后thread2苏醒，自加得到值102，并不是如预期那样thread1，100,101循环输出。当两个或多个进程需要请求共享资源时，如果想限制仅限一个进程，可以使用 Mutex，仅第一个线程独占访问权限，第二个线程进入等待，直到第一个进程释放权限。添加互斥锁后，thread2获取互斥锁，在未释放前，thread1没有访问权限进入等待。
c语言 c17标准 pdf
12-19
C语言是一种通用的编程语言，经过多年的发展，目前发布的最新版本是C17标准。C17标准为C语言的使用者提供了一些新的特性和改进，使得编程更加方便和高效。 C17标准的内容十分丰富，包括了很多新的语法规则、函数和库的新增，同时修复了之前版本的一些 bug 和问题。这些改进主要是为了让C语言更加适合于现代编程的需求，提高程序的性能和安全性。 C语言C17标准的PDF文件可以在互联网上找到并下载，其中包含了C17标准的所有内容和细节。通过阅读这份PDF文件，使用者可以了解C17标准中新增的特性和改进，以及如何在自己的项目中应用这些新特性。 对于想要深入学习C语言的程序员来说，熟悉C17标准是非常重要的。通过阅读C17标准的PDF文件，程序员可以更好地理解C语言的最新规范，同时也可以学习如何利用这些新特性来提高自己的编程水平。 总之，C语言C17标准PDF文件是学习和掌握C语言的重要工具，它为C语言的使用者提供了最新的知识和规范，帮助他们更好地应用C语言进行编程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值