C# 多线程四：互斥量Mutex的简单理解与运用

已于 2022-10-09 15:39:38 修改
阅读量3.8k 收藏 18
点赞数 6
分类专栏： C#基础知识 # 线程 Thread 文章标签： c# 开发语言
于 2022-10-08 10:12:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SmillCool/article/details/127203554
版权

目录

一. 特点：

1.非静态类继承

2.可以跨进程

二.构造函数

1.Mutex()

2.Mutex(Boolean)

2. Mutex(Boolean, String)

3.Mutex(Boolean, String, Boolean)

三.方法

一. 特点：

1.非静态类继承

Object->MarshalByRefObject->WaitHandle->Mutex （有兴趣的可以往基类深扒一下）

2.可以跨进程

   互斥实现线程同步的原理：
     只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。
     当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。
     互斥量比临界区复杂，因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的线程之间实现对资源的安全共享。

二.构造函数

创建一个类供下边调用

public class LudwigMutex {
    List<string> names;
    public LudwigMutex() {
        names = new List<string>();
    }
    public void Add(string name) {
        names.Add(name);
    }

    public void Sub() {
        if(names.Count > 0)
            names.RemoveAt(0);
    }
    public string GetString() {
        string str = "";
        for(int i = 0; i < names.Count; i++) {
            str += names[i] + " - ";
        }
        return str;
    }
}

1.Mutex()

static string[] names = new string[] { "小明", "小话", "小雅", "小斌", "小头"};
    static void Main(string[] args) {

        Mutex mutex = new Mutex();
        LudwigMutex ludwigMutex = new LudwigMutex();
        Thread thread = new Thread(() => {
            mutex.WaitOne();
            for(int i = 0; i < names.Length; i++) {
                ludwigMutex.Add(names[i]);
                Console.WriteLine(ludwigMutex.GetString());
            }
            mutex.ReleaseMutex();
        });
        Thread thread1 = new Thread(() => {
            mutex.WaitOne();
            for(int i = 0; i < names.Length; i++) {
                ludwigMutex.Sub();
                Console.WriteLine(ludwigMutex.GetString());
            }
            mutex.ReleaseMutex();
        });
        thread.Start();
        Thread.Sleep(1000);
        thread1.Start();
        Console.Read();
}

打印：

1s之后

2.Mutex(Boolean)

参数1：指示调用线程是否应具有互斥体的初始所有权

注：如果在主线程传入true，那么别的线程是获取不到锁的，除非本该线程调用ReleaseMutex()。
因此线程创建传入true时 如果不调用mutex.ReleaseMutex() 其他线程就一直拿不到互斥对象一直没法执行


例1.不调用mutex.ReleaseMutex()

static string[] names = new string[] { "小明", "小话", "小雅", "小斌", "小头"};
    static void Main(string[] args) {

        Mutex mutex = new Mutex(true);
        LudwigMutex ludwigMutex = new LudwigMutex();
        Thread thread = new Thread(() => {
            mutex.WaitOne();
            for(int i = 0; i < names.Length; i++) {
                ludwigMutex.Add(names[i]);
                Console.WriteLine(ludwigMutex.GetString());
            }
            mutex.ReleaseMutex();
        });
        Thread thread1 = new Thread(() => {
            mutex.WaitOne();
            for(int i = 0; i < names.Length; i++) {
                ludwigMutex.Sub();
                Console.WriteLine(ludwigMutex.GetString());
            }
            mutex.ReleaseMutex();
        });
        thread.Start();
        Thread.Sleep(1000);
        thread1.Start();
        Thread.Sleep(1000);
        //mutex.ReleaseMutex();
        Console.Read();
}

打印：

例2.调用mutex.ReleaseMutex()

static string[] names = new string[] { "小明", "小话", "小雅", "小斌", "小头"};
    static void Main(string[] args) {

        Mutex mutex = new Mutex(true);
        LudwigMutex ludwigMutex = new LudwigMutex();
        Thread thread = new Thread(() => {
            mutex.WaitOne();
            for(int i = 0; i < names.Length; i++) {
                ludwigMutex.Add(names[i]);
                Console.WriteLine(ludwigMutex.GetString());
            }
            mutex.ReleaseMutex();
        });
        Thread thread1 = new Thread(() => {
            mutex.WaitOne();
            for(int i = 0; i < names.Length; i++) {
                ludwigMutex.Sub();
                Console.WriteLine(ludwigMutex.GetString());
            }
            mutex.ReleaseMutex();//如果没有这一句 
        });
        thread.Start();
        Thread.Sleep(1000);
        thread1.Start();
        Thread.Sleep(1000);
        mutex.ReleaseMutex();
        Console.Read();
}

 打印：

2. Mutex(Boolean, String)

参数1：指示调用线程是否应具有互斥体的初始所有权
参数2：字符串是否为互斥体的名称

Mutex mutex = new Mutex(false, "LudwigMutex");
此时可以跨进程使用
例：
窗体应用：

public partial class Form1 : Form {
    Thread thread;
    Mutex mutex;
    bool write;
    public Form1() {
        InitializeComponent(); Init();
    }
    private void Init() {
       if(!Mutex.TryOpenExisting("LudwigMutex", out mutex))
            mutex = new Mutex(false, "LudwigMutex");
        thread = new Thread(() => {
            mutex.WaitOne();
            using(FileStream fs = File.Open("G:/111/123.txt", FileMode.OpenOrCreate)) {
                using(StreamWriter sw = new StreamWriter(fs)) {
                    while(write) {
                        sw.WriteLine("程序2写入");
                        Thread.Sleep(100);
                    }
                    sw.Close();
                }
                fs.Close();
            }
            mutex.ReleaseMutex();
        });
    }

    private void button1_Click(object sender, EventArgs e) {
        write = false;
    }

    private void button2_Click(object sender, EventArgs e) {
        thread.Start();
        write = true;
    }
}

控制台应用：

class Program {
    static string[] names = new string[] { "小明", "小话", "小雅", "小斌", "小头"};
    static void Main(string[] args) {
        Mutex mutex;
        if(!Mutex.TryOpenExisting("LudwigMutex", out mutex))
            mutex =  new Mutex(false, "LudwigMutex");

        LudwigMutex ludwigMutex = new LudwigMutex();
        Console.WriteLine("进入程序1");
        Thread thread = new Thread(() => {
            mutex.WaitOne();
            using(FileStream fs = File.Open("G:/111/123.txt", FileMode.OpenOrCreate)) {
                using(StreamWriter sw = new StreamWriter(fs)) {
                    for(int i = 0; i < names.Length; i++) {

                        ludwigMutex.Add(names[i]);
                        Console.WriteLine(ludwigMutex.GetString());
                        sw.WriteLine(names[i]);
                    }
                }
            }
            mutex.ReleaseMutex();
        });
        thread.Start();
        Thread.Sleep(1000);
        Console.Read();
}
}

效果：
1.先启动窗体应用：

 点击button2(开始锁定)

2.启动控制台应用

3.点击窗体应用的button1（解除互斥锁）
此时控制台应用打印

4.123.txt的内容为 

3.Mutex(Boolean, String, Boolean)

参数1：指示调用线程是否应具有互斥体的初始所有权
参数2：字符串是否为互斥体的名称
参数3：为了知道自己构造出来的互斥锁是不是已经存在，如果锁存在，那么createdNew的变为false，否则为true

代码如下：
1.

class Program {
    static string[] names = new string[] { "小明", "小话", "小雅", "小斌", "小头"};
    static void Main(string[] args) {
        Mutex mutex = new Mutex(false, "LudwigMutex");
        bool have = false;
        Mutex mutex1 = new Mutex(false, "LudwigMutex", out have);
        Console.WriteLine(have);
    }
}

 打印：

2.

class Program {
    static string[] names = new string[] { "小明", "小话", "小雅", "小斌", "小头"};
    static void Main(string[] args) {
        Mutex mutex = new Mutex(false, "LudwigMutex");
        bool have = false;
        Mutex mutex1 = new Mutex(false, "LudwigMutex1", out have);
        Console.WriteLine(have);
    }
}

 打印：

三.方法

OpenExisting(String)  

  打开指定的已命名的互斥体（如果已经存在）。

ReleaseMutex()   

 释放 Mutex 一次。

TryOpenExisting(String, Mutex)     

打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。

这几个方法上面例子中已有使用不再赘述

一梭键盘任平生
关注
  • 6
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C# 多线程互斥 两个线程交替工作
04-19
C# 多线程互斥 两个线程交替工作 C#多线程互斥，两个线程交替工作，如上图所示，挺有意思的。
C# 多线程的同步与互斥(使用Mutex和Event)
11-27
操作系统课的一个小作业，使用C#处理多线程的同步与互斥，使用Mutex类和AutoResetEvent类。作为一个小白，参考了其他代码写出来，某些地方还有些不完全明白，都写在注释里了，求高手指点。
C# 锁—Mutex简介
weixin_47249500的博客
04-12 1575
Mutex对象是一种锁资源，线程之间可以竞争锁资源，但同一时刻只有一条线程能成功占据锁资源。占据到锁资源的线程可以顺利执行，其余的线程阻塞。占据锁资源的线程释放锁资源后，其余的线程继续竞争，竞争成功的线程解除阻塞，以此保证线程间的同步。注意：竞争同一个Mutex实例对象的线程之间是竞争关系。竞争不同Mutex实例对象的线程之间不存在竞争关系。
C#中Mutex对象用法分析
12-25
本文实例讲述了C#中Mutex对象用法。分享给大家供大家参考，具体如下： C#语言有很多值得学习的地方，这里我们就来介绍C# Mutex对象，包括介绍控制好多个线程相互之间的联系等方面。 如何控制好多个线程相互之间的联系，不产生冲突和重复，这需要用到互斥对象，即：System.Threading 命名空间中的 Mutex 类。 我们可以把Mutex看作一个出租车，乘客看作线程。乘客首先等车，然后上车，最后下车。当一个乘客在车上时，其他乘客就只有等他下车以后才可以上车。而线程与C# Mutex对象的关系也正是如此，线程使用Mutex.WaitOne()方法等待C# Mutex对象被释放，如果它等
c#Mutex的用法总结
qq_34059233的博客
05-13 6068
1、Mutex在线程中的使用； 2、Mutex在进程中的使用；
线程同步之互斥量mutex的使用
betsyfeng的专栏
05-08 1282
<br />什么是Mutex<br />　　“mutex”是术语“互相排斥（mutually exclusive）”的简写形式，也就是互斥量。互斥量跟临界区中提到的Monitor很相似，只有拥有互斥对象的线程才具有访问资源的权限，由于互斥对象只有一个，因此就决定了任何情况下此共享资源都不会同时被多个线程所访问。当前占据资源的线程在任务处理完后应将拥有的互斥对象交出，以便其他线程在获得后得以访问资源。互斥量比临界区复杂，因为使用互斥不仅仅能够在同一应用程序不同线程中实现资源的安全共享，而且可以在不同应用程序的
C#中Mutex的用法
beautifull001的博客
02-27 5865
C#中Mutex是互斥锁，位于System.Threading 命名空间中。 顾名思义，它是一个互斥的对象，同一时间只有一个线程可以拥有它，该类还可用于进程间同步的同步基元。 如果当前有一个线程拥有它，在没有释放之前，其它线程是没有权利拥有它的。我们可以把Mutex看作洗手间，上厕所的人看作线程；上厕所的人先进洗手间，拥有使用权，上完厕所之后出来，把洗手间释放，其他人才可以使用。 线程使用M...
C#多线程中如何运用互斥锁Mutex
08-30
主要为大家详细介绍了C#多线程中如何运用互斥锁Mutex，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
C# 多线程同步与互斥，使用Mutex和AutoResetEvent类
11-27
C# 使用Mutex和AutoResetEvent类处理多线程同步与互斥，调试并完善了网上文档的代码。经测试能很好地实现要求，但还有一些地方不是特别明白，都写在注释中了，请高手给予指点。
Linux线程管理必备：互斥量与条件变量
01-09
而互斥量与条件变量在线程管理中必不可少，任务间的调度几乎都是由互斥量与条件变量控制。互斥量的实现与进程中的信号量（无名信号量）是类似的，当然，信号量也可以用于线程，区别在于初始化的时候，其本质都是P/V...
C#（五十四）之线程Mutex互斥
camellia的博客
07-06 644
在声明mutex对象时，在构造函数中传入该线程的名字，两个应用线程的名字相同，我们就认为该mutex线程时系统互斥线程。利用所需的安全访问权限，打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。使用可指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称。使用可指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称。打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。用一个指示调用线程是否应拥有互斥体的初始所属权的布尔值。
C#之：线程同步 Mutex类
C++++ ++
08-26 1905
Mutex（互斥锁）： Mutex： 命名空间:System.Threading 一个同步基元，也可用于进程间同步。是.NET Framework 中提供跨多个线程，或多个进程同步访问的一个类。它非常类似于Monitor类，他们都只有一个线程能拥有锁定，只有一个线程能获得互斥锁，访问受互斥保护的同步代码区域。 在 Mutex 类的构造函数中，可以指定互斥是否最初应有主线程拥有，定义互斥的名称，获得...
C#使用Mutex实现单例应用程序
月亮哥的专栏
01-03 375
C#使用Mutex实现单例应用程序
C#多线程 - Mutex
Kevin.Chen - 专注前行
09-29 1359
System.Threading.Mutex在概念上和System.Threading.Monitor几乎完全一致，只是lock关键字用的不是它，而且它旨在进程间的同步。Codeusing System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threading;namespace myConApp{    class Test    {        ///         /// 
通过实例学C#之Mutex（互斥锁）类
最新发布
lgh65200的博客
04-13 1337
如果创建实例时，填入一个bool参数，那么表示，在创建该互斥锁的同时，会相应控制互斥锁的所有权，如果参数为True，表示创建互斥锁的线程，具有互斥锁的所有权，如果它不使用ReleaseMux（）释放互斥锁的所有权，那么其他使用互斥锁的线程，将一直被阻塞。例如，设备J对工件X的温度进行判断，得知工件的温度满足条件后，可以进行下一个工艺操作，此时，如果另一个设备K对工件X进行降温操作，那么，工件X的温度就不满足执行后续制作工艺条件，这时候，如果强行进行后续操作，可能会产生次品。
C#Mutex类用法总结
qq_30725967的博客
05-14 9145
定义： Mutex跨多个线程同步访问的类。只有一个线程能获得互斥锁定，访问受互斥保护的同步代码区域。 说明： 在Mutex类的构造函数中，可以指定互斥是否最初应由主调线程拥有，定义互斥的名称，获得互斥是否已存在的信息。 实例如下： //引用命名空间 using System.Threading; bool flag = false; Mutex mutex = new Mutex(false, “...
在c#中用mutex类实现线程的互斥_C# 多线程系列（4）进程同步Mutex类
weixin_39940154的博客
11-23 407
Mutex 类Mutex 中文为互斥，Mutex 类叫做互斥锁。它还可用于进程间同步的同步基元。Mutex 跟 lock 相似，但是 Mutex 支持多个进程。Mutex 大约比 lock 慢 20 倍。互斥锁(Mutex)，用于多线程中防止两条线程同时对一个公共资源进行读写的机制。Windows 操作系统中，Mutex 同步对象有两个状态：signaled：未被任何对象拥有；nonsi...
C#基本概念之Mutex---互斥锁
weixin_33696106的博客
12-27 343
在编程中，引入了对象互斥锁的概念，来保证共享数据操作的完整性。每个对象都对应于一个可称为" 互斥锁" 的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。中文名互斥锁领域汇编语言示例下面举例：在Posix Thread中定义有一套专门用于线程同步的mutex函数。1． 创建和销毁有两种方法创建互斥锁，静态方式和动态方式。POSIX定义了一个宏PTHREAD_...
C#多线程着怎么线程同步
07-13
在C#中，我们可以使用线程同步技术来确保多个线程之间的正确协调和互斥访问共享资源。以下是一些常用的线程同步技术： 1. 互斥锁（Mutex）：互斥锁是一种最基本的线程同步机制，它确保在任何时候只有一个线程可以访问被保护的资源。通过`lock`关键字或`Mutex`类来实现互斥锁。 ```csharp private static readonly object lockObject = new object(); lock (lockObject) { // 访问共享资源的代码 } ``` 2. 信号量（Semaphore）：信号量是一种计数器，它限制同时访问某个资源的线程数量。通过`Semaphore`类来实现信号量。 ```csharp private static Semaphore semaphore = new Semaphore(2, 2); // 允许同时两个线程访问 semaphore.WaitOne(); // 请求访问资源 try { // 访问共享资源的代码 } finally { semaphore.Release(); // 释放资源 } ``` 3. 事件（Event）：事件是一种线程间的通信机制，它允许一个或多个线程等待某个操作完成。通过`ManualResetEvent`或`AutoResetEvent`类来实现事件。 ```csharp private static ManualResetEvent eventObject = new ManualResetEvent(false); // 初始状态为非终止状态 // 线程1等待事件 eventObject.WaitOne(); // 线程2触发事件 eventObject.Set(); ``` 4. 互斥体（Monitor）：互斥体是一种特殊的内核对象，它提供了一种同步机制，确保只有一个线程可以进入临界区。通过`Monitor`类来实现互斥体。 ```csharp private static readonly object lockObject = new object(); Monitor.Enter(lockObject); try { // 访问共享资源的代码 } finally { Monitor.Exit(lockObject); } ``` 这些线程同步技术可以帮助你在多线程环境中实现线程安全和资源互斥访问。根据实际需求，选择适合的同步机制来确保线程间的正确协调。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一梭键盘任平生

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值