c#Mutex的用法总结

已于 2023-02-10 21:21:54 修改
阅读量6.1k 收藏 40
点赞数 8
分类专栏： c# 文章标签： c#
于 2020-05-13 10:07:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34059233/article/details/106043744
版权
c# 专栏收录该内容
158 篇文章 164 订阅
订阅专栏

msdn中对于Mutex的解释是：可用于进程间同步的同步基元，顾名思义也就是可用于进程中的同步，并且c#本质论中也提出了Mutex可以用于同步对文件或者其它跨进程资源的访问，下面就有几个疑问？
1、Mutex能不能用于同一进程下的不同线程的同步？
答：Mutex可以用于同一进程下不同线程的同步。
1）

 private static int count=0;
        public Form1()
        {
            InitializeComponent();

            Task task1 = Task.Run(()=> Increase());

            Task task2 = Task.Run(()=>Decrease());


            Task.WaitAll (new Task[] { task1,task2});
            Console.WriteLine(count);
        }
  private static void Increase()
        {
            for(int i=0;i<int.MaxValue;i++)
            {
                count++;
            }
        }
   private static void Decrease()
        {
            for(int i=0;i<int.MaxValue;i++)
            {
                count--;
            }
        }

最终控制台输出的结果是-456690760，而非我们想象的0，这就是由于多个线程访问相同的数据造成了竞态条件导致，下面我们使用Mutex来实现对count变量的同步，如下：

  private static int count = 0;
        Mutex mutex = new Mutex(false );
        public Form1()
        {
            InitializeComponent();

            Task task1 = Task.Run(() => Increase());

            Task task2 = Task.Run(() => Decrease());


            Task.WaitAll(new Task[] { task1, task2 });

            Console.WriteLine(count);
        }
        private void Increase()
        {
            mutex.WaitOne();//申请互斥体

            for (int i = 0; i < int.MaxValue; i++)
            {
                count++;
            }
            mutex.ReleaseMutex();



        }

        private void Decrease()
        {
            mutex.WaitOne();
            for (int i = 0; i < int.MaxValue; i++)
            {
                count--;
            }
            mutex.ReleaseMutex();
        }

2、Mutex在跨进程中怎么使用？
下面举两个例子说明Mutex在跨进程中的使用；
1）防止应用程序被打开两次；
static void Main()
{
bool createNew;
Mutex mt = new Mutex(true, “ApplicationMutex”, out createNew);

        if (createNew)
        {
            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            Application.Run(new Form1());
        }
        else
        {
            MessageBox.Show("程序已经打开！");
            Process.GetCurrentProcess().Kill();
        }
    }

上述代码中就是利用Mutex构造函数的第三个参数来防止程序被多次打开，Msdn的解释是：
如果创建了局部互斥体（即，如果 name 为 null 或空字符串）或指定的命名系统互斥体，则createdNew 返回true；如果指定的命名系统互斥体已存在，则为 createdNew 返回false。
2）Mutex在多个进程中访问文件时实现同步；
多进程不同步对文件的访问时：
System.IO.IOException:“文件“d:\TestFile\1.txt”正由另一进程使用，因此该进程无法访问此文件。”
进程一如下：

 public partial class Form1 : Form
    {

        Mutex mutex = new Mutex(false, "MyMutex");
        public Form1()
        {
            InitializeComponent();

            Thread thread = new Thread(WriteFile);
            thread.IsBackground = true;
            thread.Start("d:\\TestFile\\1.txt");
        }

        private void WriteFile(object fileName)
        {
            while (true)
            {
                string TempfileName = fileName.ToString();
                //mutex.WaitOne();
                StreamWriter sw = new StreamWriter(TempfileName, false, Encoding.GetEncoding("GB2312"));
                sw.WriteLine(DateTime.Now.ToString());
                sw.Flush();
                sw.Close();
                //mutex.ReleaseMutex();
                Thread.Sleep(10);
            }
        }
    }

进程二如下：

  public partial class Form1 : Form
    {
       
        Mutex mutex = new Mutex(false, "MyMutex");
        public Form1()
        {
            InitializeComponent();

            Thread thread = new Thread(ReadFile);
            thread.IsBackground = true;
            thread.Start("d:\\TestFile\\1.txt");
        }
        private void ReadFile(object  fileName)
        {
            while(true)
            {
                string tempFileName = fileName.ToString();
                string str;
              
                //mutex.WaitOne();
                StreamReader sr = new StreamReader(tempFileName, Encoding.GetEncoding("GB2312"));
                str = sr.ReadLine();
                Thread.Sleep(10);
                sr.Close();
                //mutex.ReleaseMutex();
                this.Invoke(new Action (() => label1.Text = str));
            }
            
        }
    }

同时运行这个两个进程后，就会报出文件被另一进程占用的异常。
多进程同步对文件的访问：
进程一如下：

  public partial class Form1 : Form
    {

        Mutex mutex = new Mutex(false, "MyMutex");
        public Form1()
        {
            InitializeComponent();

            Thread thread = new Thread(WriteFile);
            thread.IsBackground = true;
            thread.Start("d:\\TestFile\\1.txt");
        }

        private void WriteFile(object fileName)
        {
            while (true)
            {
                string TempfileName = fileName.ToString();
                mutex.WaitOne();
                StreamWriter sw = new StreamWriter(TempfileName, false, Encoding.GetEncoding("GB2312"));
                sw.WriteLine(DateTime.Now.ToString());
                sw.Flush();
                sw.Close();
                mutex.ReleaseMutex();
                Thread.Sleep(10);
            }
        }
    }

进程二如下：

  public partial class Form1 : Form
    {

        Mutex mutex = new Mutex(false, "MyMutex");
        public Form1()
        {
            InitializeComponent();

            Thread thread = new Thread(ReadFile);
            thread.IsBackground = true;
            thread.Start("d:\\TestFile\\1.txt");
        }
        private void ReadFile(object fileName)
        {
            while (true)
            {
                string tempFileName = fileName.ToString();
                string str;
                mutex.WaitOne();
                StreamReader sr = new StreamReader(tempFileName, Encoding.GetEncoding("GB2312"));
                str = sr.ReadLine();
                Thread.Sleep(10);
                sr.Close();
                mutex.ReleaseMutex();
                this.Invoke(new Action(() => label1.Text = str));
            }

        }
    }

3、常见错误及原因分析
1）System.ApplicationException:“从不同步的代码块中调用了对象同步方法

 private void Decrease()
        {
            for (int i = 0; i < int.MaxValue; i++)
            {
                count--;
            }
            mutex.ReleaseMutex();
        }

 private static int count = 0;
        Mutex mutex = new Mutex(true);
        public Form1()
        {
            InitializeComponent();

            

           Task task2 = Task.Run(() => Decrease());
            Thread.Sleep(10000);
           
            //Task task1 = Task.Run(() => Increase());


            //Task.WaitAll(new Task[] { task1, task2 });

            Console.WriteLine(count);
        }

上面的代码就会报这个错误，这是由于Mutex创建对象时，第一个参数为true， Mutex mutex = new Mutex(true);这个true的意思是让创建这个同步对象的线程拥有互斥体，这里创建互斥体的线程是UI线程，但是我们在Task2中调用了mutex.ReleaseMutex()这个同步方法，而Mutex使用时就有一个规定拥有互斥体的线程才可以去释放互斥体，所以出现了上面的错误，如果将代码改成下面这两种情况，则就不会出问题。
情况一、直接在UI线程调用ReleaseMutex

public Form1()
        {
            InitializeComponent();

            Decrease();

           //Task task2 = Task.Run(() => Decrease());
            Thread.Sleep(10000);
           
            //Task task1 = Task.Run(() => Increase());


            //Task.WaitAll(new Task[] { task1, task2 });

            Console.WriteLine(count);
        }

情况二、在task2中创建Mutex的对象

    public partial class Form1 : Form
{
    private static int count = 0;

    public Form1()
    {
        InitializeComponent();



        Task task2 = Task.Run(() => Decrease());
        Thread.Sleep(10000);

        //Task task1 = Task.Run(() => Increase());


        //Task.WaitAll(new Task[] { task1, task2 });

        Console.WriteLine(count);
    }
    //private void Increase()
    //{
    //    mutex.WaitOne();

    //    for (int i = 0; i < int.MaxValue; i++)
    //    {
    //        count++;
    //    }
    //    mutex.ReleaseMutex();



    //}

    private void Decrease()
    {
        Mutex mutex = new Mutex(true);
        for (int i = 0; i < int.MaxValue; i++)
        {
            count--;
        }
        mutex.ReleaseMutex();
    }
}

2)System.Threading.AbandonedMutexException:“由于出现被放弃的 mutex，等待过程结束。”
msdn中指出，如果一个线程终止时拥有互斥体，则认为该互斥量将放弃。 互斥体的状态将设置为终止状态，并等待下一步的线程获取所有权。也就是说线程程序执行完毕，但是线程用的Mutex对象没有release，如果这时再次申请互斥体，则认为互斥体的代码已经执行完毕了，申请互斥体的线程可以获取互斥体，但是这里有一个线程申请互斥体时间的问题，如果拥有互斥体的线程1中的代码没有执行完毕，线程2调用waitone申请互斥体，那么当线程1代码执行完毕，但是没有release掉mutex的话，则线程2就会报System.Threading.AbandonedMutexException这个错误，所以我们在使用中一定要注意释放Mutex的实例，报错代码如下：

public partial class Form1 : Form
    {
        private static int count = 0;
        Mutex mutex;
        public Form1()
        {
            InitializeComponent();



            Task task2 = Task.Run(() => Decrease());
           

           Task task1 = Task.Run(() => Increase());


            Task.WaitAll(new Task[] { task1, task2 });

            Console.WriteLine(count);
        }
        private void Increase()
        {
            mutex.WaitOne();

            for (int i = 0; i < int.MaxValue; i++)
            {
                count++;
            }
            mutex.ReleaseMutex();
            Console.WriteLine("递增线程结束");
        }

        private void Decrease()
        {
             mutex = new Mutex(true);
            for (int i = 0; i < int.MaxValue; i++)
            {
                count--;
            }
            //mutex.ReleaseMutex();
            Console.WriteLine("递减线程结束");
        }
    }

如果上述代码中线程task1在task2执行完毕后再去申请互斥体，则不会报错，代码如下：

 public partial class Form1 : Form
    {
        private static int count = 0;
        Mutex mutex;
        public Form1()
        {
            InitializeComponent();



            Task task2 = Task.Run(() => Decrease());

            Thread.Sleep(10000);
           Task task1 = Task.Run(() => Increase());


            Task.WaitAll(new Task[] { task1, task2 });

            Console.WriteLine(count);
        }
        private void Increase()
        {
            mutex.WaitOne();

            for (int i = 0; i < int.MaxValue; i++)
            {
                count++;
            }
            mutex.ReleaseMutex();
            Console.WriteLine("递增线程结束");
        }

        private void Decrease()
        {
             mutex = new Mutex(true);
            for (int i = 0; i < int.MaxValue; i++)
            {
                count--;
            }
            mutex.ReleaseMutex();
            Console.WriteLine("递减线程结束");
        }
    }
c#上位机
关注
  • 8
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C#中Mutex对象用法分析
12-25
本文实例讲述了C#中Mutex对象用法。分享给大家供大家参考，具体如下： C#语言有很多值得学习的地方，这里我们就来介绍C# Mutex对象，包括介绍控制好多个线程相互之间的联系等方面。 如何控制好多个线程相互之间的联系，不产生冲突和重复，这需要用到互斥对象，即：System.Threading 命名空间中的 Mutex 类。 我们可以把Mutex看作一个出租车，乘客看作线程。乘客首先等车，然后上车，最后下车。当一个乘客在车上时，其他乘客就只有等他下车以后才可以上车。而线程与C# Mutex对象的关系也正是如此，线程使用Mutex.WaitOne()方法等待C# Mutex对象被释放，如果它等
C#使用Mutex简单实现程序单实例运行的方法
09-03
实现这一目标的一种方法是使用`Mutex`（互斥锁）类，它提供了多线程环境下的同步机制。在本教程中，我们将深入探讨如何使用C#的`Mutex`来实现程序的单实例运行。 `Mutex`是一种系统范围内的同步对象，它可以阻止多...
通过实例学C#之Mutex（互斥锁）类
最新发布
lgh65200的博客
04-13 1380
如果创建实例时，填入一个bool参数，那么表示，在创建该互斥锁的同时，会相应控制互斥锁的所有权，如果参数为True，表示创建互斥锁的线程，具有互斥锁的所有权，如果它不使用ReleaseMux（）释放互斥锁的所有权，那么其他使用互斥锁的线程，将一直被阻塞。例如，设备J对工件X的温度进行判断，得知工件的温度满足条件后，可以进行下一个工艺操作，此时，如果另一个设备K对工件X进行降温操作，那么，工件X的温度就不满足执行后续制作工艺条件，这时候，如果强行进行后续操作，可能会产生次品。
C# 锁—Mutex简介
weixin_47249500的博客
04-12 1695
Mutex对象是一种锁资源，线程之间可以竞争锁资源，但同一时刻只有一条线程能成功占据锁资源。占据到锁资源的线程可以顺利执行，其余的线程阻塞。占据锁资源的线程释放锁资源后，其余的线程继续竞争，竞争成功的线程解除阻塞，以此保证线程间的同步。注意：竞争同一个Mutex实例对象的线程之间是竞争关系。竞争不同Mutex实例对象的线程之间不存在竞争关系。
C#之：线程同步 Mutex类
C++++ ++
08-26 1922
Mutex（互斥锁）： Mutex： 命名空间:System.Threading 一个同步基元，也可用于进程间同步。是.NET Framework 中提供跨多个线程，或多个进程同步访问的一个类。它非常类似于Monitor类，他们都只有一个线程能拥有锁定，只有一个线程能获得互斥锁，访问受互斥保护的同步代码区域。 在 Mutex 类的构造函数中，可以指定互斥是否最初应有主线程拥有，定义互斥的名称，获得...
C#使用Mutex实现单例应用程序
月亮哥的专栏
01-03 385
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对象深入理解
漫漫长途，终有回转；余味苦涩，终有回甘
12-18 7394
最近小编新入职了一家公司，在熟悉系统的过程中发现Mutex对象，后来小编学习了一下，本文主要是讲解何为Mutex，以及Mutex的一些用法。 概念     C#中Mutex是互斥锁，位于System.Threading 命名空间中。     记得在之前的学习过程中接触到锁这个概念，结合锁的概念，再来解释一下，互斥锁是一种互斥的同步对象，意味着同一时间有且仅有一个线程。Mute
c#-线程同步-Mutex(互斥锁)-简单实验
xie__jin__cheng的博客
02-12 314
概述 bool mutexCreated; var mutex = new Mutex(false, "sigletonAppMutex", out mutexCreated); 参数说明 参数位置 参数 说明 1 false 2 sigletonAppMutex 设置互斥的名称 3 mutexCreated 该名称的互斥是否存在 特点 1.可以跨进程，这是个系统级别的互斥。 2.用于控制程序不能打开两次。 3.当日也可以做..
C#中的lock、Monitor、Mutex学习笔记
09-03
总结来说，C#中的lock、Monitor和Mutex提供了不同层次和场景下的线程同步解决方案。lock是最基础的同步机制，适用于简单的情况；Monitor提供了更灵活的控制，包括避免死锁和优化等待策略；而Mutex则适用于跨进程的...
C#的多线程能力(Mutex的作用)
genispan的专栏
09-15 2375
System.Threading.Mutex ：同步基元，它只向一个线程授予对共享资源的独占访问权。当有两个或两个以上的线程要对一个共享资源进行操作的时候，就要System.Threading.Mutex互斥体来进行调节。保证只有一个线程可以对共享资源进行控制。如果一个线程获得了互斥体，其他线程只能在第一个线程放弃互斥体之前先挂起。互斥体可以通过waitone()请求相同的
C#中Mutex的用法
weixin_30552811的博客
11-23 633
C#中Mutex是互斥锁，位于System.Threading 命名空间中。 顾名思义，它是一个互斥的对象，同一时间只有一个线程可以拥有它，该类还可用于进程间同步的同步基元。 如果当前有一个线程拥有它，在没有释放之前，其它线程是没有权利拥有它的。我们可以把Mutex看作洗手间，上厕所的人看作线程；上厕所的人先进洗手间，拥有使用权，上完厕所之后出来，把洗手间释放，其他人才可...
C#开发之——Mutex(14.8)
我的博客
08-06 375
一 概述 C#中Mutex类也是用于线程同步操作的类，例如，当多个线程同时访问一个资源时保证一次只能有一个线程访问资源 在Mutex类中，WaitOne()方法用于等待资源被释放，ReleaseMutex()方法用于释放资源 WaitOne()方法在等待ReleaseMutex()方法执行结束后才会结束 <!--more--> 二 实例 使用线程互斥实现每个车位每次只能停一辆车的功能 2.1 代码 <span style="color:#33333..
C#Mutex的使用
weixin_30460489的博客
07-04 106
C#Mutex的使用 bool blFlag = false; Mutex mtx = new Mutex(false, "Form1", out blFlag); if (!blFlag) { MessageBox.Show("软件已启动"); Application.Exit(); } else { Application.EnableVi...
C# 浅析并行任务同步机制——Mutex类
scu_Bao的专栏
03-18 319
一、Mutex类 Mutex(mutual exclusion，互斥)，是.Net Frameworkt中提供跨多个进程同步访问的一个类。 注：一次只能有一个线程访问互斥保护的同步代码区域。 二、应用场景 可以禁止同一应用程序启动两次。 /// <summary> /// App.xaml 的交互逻辑 /// </summary> public partial class App : Applica...
C#的Mutex使用
qq_40242160的博客
04-17 609
可以和C++的Mutex的对比着用。https://blog.csdn.net/qq_40242160/article/details/105490284 包含using System.Threading; 1. 创建 Mutex m_mutex = new Mutex(true); 2. 等待获取 m_mutex.WaitOne(); 3. 释放 m_mutex.Relea...
线程、同步与锁——Mutex想说爱你不容易
king16304的博客
08-10 1688
除了Lock（）、Monitor之外，我们最长用的就是Mutex了，但是玩不好Mutex就总会造成死锁或者AbandonedMutexException（我就玩的不怎么好，在并发性访问测试的时候总是遇到关于Mutex的问题，各位线虫见笑了，不过还是把我遇到的一些问题和总结拿出来和大家分享，有误的地方还往指正。 还是先举一个简单的例子，来说明一下这个东西：    public c
演示下c#的mutex的用法
05-18
当多个线程需要访问共享资源时，为了避免数据竞争和死锁等问题，我们可以使用互斥量（Mutex）来实现线程同步。下面是一个简单的 C# 代码示例，演示了如何使用 Mutex 来保护共享资源。 ```csharp using System; using System.Threading; class Program { static Mutex mut = new Mutex(); static void Main() { for (int i = 0; i < 5; i++) { Thread myThread = new Thread(DoWork); myThread.Name = String.Format("Thread{0}", i + 1); myThread.Start(); } } static void DoWork() { mut.WaitOne(); // 等待互斥量可用 Console.WriteLine("{0} 开始执行任务……", Thread.CurrentThread.Name); // 这里模拟一些耗时的操作 Thread.Sleep(2000); Console.WriteLine("{0} 完成任务。", Thread.CurrentThread.Name); mut.ReleaseMutex(); // 释放互斥量 } } ``` 在这个示例中，我们创建了一个 Mutex 对象 `mut`，然后在 `DoWork` 方法中使用 `WaitOne` 方法来获取互斥量。如果互斥量已经被另一个线程占用，则当前线程会被阻塞，直到互斥量可用。然后我们执行一些模拟的耗时操作，最后使用 `ReleaseMutex` 方法来释放互斥量，让其他线程可以访问共享资源。 需要注意的是，Mutex 对象是进程内的同步对象，不同进程之间不能共享。在使用 Mutex 时，我们需要确保调用 `ReleaseMutex` 方法的线程与调用 `WaitOne` 方法的线程是同一个线程，否则会导致死锁。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

c#上位机

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

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

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

打赏作者

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

抵扣说明：

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

余额充值