首页 > 资讯 > 后端开发 > 其他教程 >C#多线程系列之进程同步Mutex类

677

分享到

C#多线程系列之进程同步Mutex类

2024-04-02 19:04:59 677人浏览独家记忆

摘要

Mutex 中文为互斥，Mutex 类叫做互斥锁。它还可用于进程间同步的同步基元。 Mutex 跟 lock 相似，但是 Mutex 支持多个进程。Mutex 大约比 lock 慢

Mutex 中文为互斥，Mutex 类叫做互斥锁。它还可用于进程间同步的同步基元。

Mutex 跟 lock 相似，但是 Mutex 支持多个进程。Mutex 大约比 lock 慢 20 倍。

互斥锁(Mutex)，用于多线程中防止两条线程同时对一个公共资源进行读写的机制。

windows 操作系统中，Mutex 同步对象有两个状态：

signaled：未被任何对象拥有；
nonsignaled：被一个线程拥有；

Mutex 只能在获得锁的线程中，释放锁。

构造函数和方法

Mutex 类其构造函数如下：

构造函数	说明
Mutex()	使用默认属性初始化 Mutex类的新实例。
Mutex(Boolean)	使用 Boolean 值（指示调用线程是否应具有互斥体的初始所有权）初始化 Mutex 类的新实例。
Mutex(Boolean, String)	使用 Boolean 值（指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称）初始化 Mutex 类的新实例。
Mutex(Boolean, String, Boolean)	使用可指示调用线程是否应具有互斥体的初始所有权以及字符串是否为互斥体的名称的 Boolean 值和当线程返回时可指示调用线程是否已赋予互斥体的初始所有权的 Boolean 值初始化 Mutex 类的新实例。

Mutex 对于进程同步有所帮助，例如其应用场景主要是控制系统只能运行一个此程序的实例。

Mutex 构造函数中的 String类型参数叫做互斥量而互斥量是全局的操作系统对象。
Mutex 只要考虑实现进程间的同步，它会耗费比较多的资源，进程内请考虑 Monitor/lock。

Mutex 的常用方法如下：

方法	说明
Close()	释放由当前 WaitHandle 占用的所有资源。
Dispose()	释放由 WaitHandle 类的当前实例占用的所有资源。
OpenExisting(String)	打开指定的已命名的互斥体（如果已经存在）。
ReleaseMutex()	释放 Mutex一次。
TryOpenExisting(String, Mutex)	打开指定的已命名的互斥体（如果已经存在），并返回指示操作是否成功的值。
WaitOne()	阻止当前线程，直到当前 WaitHandle 收到信号。
WaitOne(Int32)	阻止当前线程，直到当前 WaitHandle 收到信号，同时使用 32 位带符号整数指定时间间隔（以毫秒为单位）。
WaitOne(Int32, Boolean)	阻止当前线程，直到当前的 WaitHandle 收到信号为止，同时使用 32 位带符号整数指定时间间隔，并指定是否在等待之前退出同步域。
WaitOne(TimeSpan)	阻止当前线程，直到当前实例收到信号，同时使用 TimeSpan 指定时间间隔。
WaitOne(TimeSpan, Boolean)	阻止当前线程，直到当前实例收到信号为止，同时使用 TimeSpan 指定时间间隔，并指定是否在等待之前退出同步域。

关于 Mutex 类，我们可以先通过几个示例去了解它。

系统只能运行一个程序的实例

下面是一个示例，用于控制系统只能运行一个此程序的实例，不允许同时启动多次。

    class Program
    {
        // 第一个程序
        const string name = "www.whuanle.cn";
        private static Mutex m;
        static void Main(string[] args)
        {
            // 本程序是否是 Mutex 的拥有者
            bool firstInstance;
            m = new Mutex(false,name,out firstInstance);
            if (!firstInstance)
            {
                Console.WriteLine("程序已在运行！按下回车键退出！");
                Console.ReadKey();
                return;
            }
            Console.WriteLine("程序已经启动");
            Console.WriteLine("按下回车键退出运行");
            Console.ReadKey();
            m.ReleaseMutex();
            m.Close();
            return;
        }
    }

上面的代码中，有些地方前面没有讲，没关系，我们运行一下生成的程序先。

解释一下上面的示例

Mutex 的工作原理：

当两个或两个以上的线程同时访问共享资源时，操作系统需要一个同步机制来确保每次只有一个线程使用资源。

Mutex 是一种同步基元，Mutex 仅向一个线程授予独占访问共享资源的权限。这个权限依据就是互斥体，当一个线程获取到互斥体后，其它线程也在试图获取互斥体时，就会被挂起(阻塞)，直到第一个线程释放互斥体。

对应我们上一个代码示例中，实例化 Mutex 类的构造函数如下：

m = new Mutex(false,name,out firstInstance);

其构造函数原型如下：

public Mutex (bool initiallyOwned, string name, out bool createdNew);

前面我们提出过，Mutex 对象有两种状态，signaled 和 nonsignaled。

通过 new 来实例化 Mutex 类，会检查系统中此互斥量 name 是否已经被使用，如果没有被使用，则会创建 name 互斥量并且此线程拥有此互斥量的使用权；此时 createdNew == true。

那么 initiallyOwned ，它的作用是是否允许线程是否能够获取到此互斥量的初始化所有权。因为我们希望只有一个程序能够在后台运行，因此我们要设置为 false。

驱动开发中关于Mutex ：https://docs.microsoft.com/zh-cn/windows-hardware/drivers/kernel/introduction-to-mutex-objects

对了， Mutex 的参数中，name 是非常有讲究的。

在运行终端服务的服务器上，命名系统 mutex 可以有两个级别的可见性。

如果其名称以前缀 "Global" 开头，则 mutex 在所有终端服务器会话中可见。
如果其名称以前缀 "Local" 开头，则 mutex 仅在创建它的终端服务器会话中可见。在这种情况下，可以在服务器上的其他每个终端服务器会话中存在具有相同名称的单独 mutex。

如果在创建已命名的 mutex 时未指定前缀，则采用前缀 "Local"。在终端服务器会话中，两个互斥体的名称只是它们的前缀不同，它们都是对终端服务器会话中的所有进程都可见。

也就是说，前缀名称 "Global" 和 "Local" 描述互斥体名称相对于终端服务器会话的作用域，而不是相对于进程。

请参考：

Https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.mutex?view=netcore-3.1#methods

https://www.jb51.net/article/237313.htm

接替运行

这里要实现，当同时点击一个程序时，只能有一个实例A可以运行，其它实例进入等待队列，等待A运行完毕后，然后继续运行队列中的下一个实例。

我们将每个程序比作一个人，模拟一个厕所坑位，每次只能有一个人上厕所，其他人需要排队等候。

使用 WaitOne() 方法来等待别的进程释放互斥量，即模拟排队；ReleaseMutex() 方法解除对坑位的占用。

    class Program
    {
        // 第一个程序
        const string name = "www.whuanle.cn";
        private static Mutex m;
        static void Main(string[] args)
        {
            // wc 还有没有位置
            bool firstInstance;
            m = new Mutex(true,name,out firstInstance);

            // 已经有人在上wc
            if (!firstInstance)
            {
                // 等待运行的实例退出，此进程才能运行。
                Console.WriteLine("排队等待");
                m.WaitOne();
                GoWC();
                return;
            }
            GoWC();

            return;
        }

        private static void GoWC()
        {
            Console.WriteLine(" 开始上wc");
            Thread.Sleep(1000);
            Console.WriteLine(" 开门");
            Thread.Sleep(1000);
            Console.WriteLine(" 关门");
            Thread.Sleep(1000);
            Console.WriteLine(" xxx");
            Thread.Sleep(1000);
            Console.WriteLine(" 开门");
            Thread.Sleep(1000);
            Console.WriteLine(" 离开wc");
            m.ReleaseMutex();
            Thread.Sleep(1000);
            Console.WriteLine(" 洗手");
        }
    }

此时，我们使用了

            m = new Mutex(true,name,out firstInstance);

一个程序结束后，要允许其它线程能够创建 Mutex 对象获取互斥量，需要将构造函数的第一个参数设置为 true。

你也可以改成 false，看看会报什么异常。

你可以使用 WaitOne(Int32) 来设置等待时间，单位是毫秒，超过这个时间就不排队了，去别的地方上厕所。

为了避免出现问题，请考虑在 finally 块中执行 m.ReleaseMutex()。

进程同步示例

这里我们实现一个这样的场景：

父进程 Parent 启动子进程 Children ，等待子进程 Children 执行完毕，子进程退出，父进程退出。

新建一个 .net core 控制台项目，名称为 Children，其 Progarm 中的代码如下

using System;
using System.Threading;

namespace Children
{
    class Program
    {
        const string name = "进程同步示例";
        private static Mutex m;
        static void Main(string[] args)
        {
            Console.WriteLine("子进程被启动...");
            bool firstInstance;

            // 子进程创建互斥体
            m = new Mutex(true, name, out firstInstance);

            // 按照我们设计的程序，创建一定是成功的
            if (firstInstance)
            {
                Console.WriteLine("子线程执行任务");
                DoWork();
                Console.WriteLine("子线程任务完成");

                // 释放互斥体
                m.ReleaseMutex();
                // 结束程序
                return;
            }
            else
            {
                Console.WriteLine("莫名其妙的异常，直接退出");
            }
        }
        private static void DoWork()
        {
            for (int i = 0; i < 5; i++)
            {
                Console.WriteLine("子线程工作中");
                Thread.Sleep(TimeSpan.FromSeconds(1));
            }
        }
    }
}

然后发布或生成项目，打开程序文件位置，复制线程文件路径。
创建一个新项目，名为 Parent 的 .Net Core 控制台，其 Program 中的代码如下：

using System;
using System.Diagnostics;
using System.Threading;

namespace Parent
{
    class Program
    {
        const string name = "进程同步示例";
        private static Mutex m;
        static void Main(string[] args)
        {
            // 晚一些再执行，我录屏要对正窗口位置
            Thread.Sleep(TimeSpan.FromSeconds(3));
            Console.WriteLine("父进程启动！");

            new Thread(() =>
            {
                // 启动子进程
                Process process = new Process();
                process.StartInfo.UseshellExecute = true;
                process.StartInfo.CreateNoWindow = false;
                process.StartInfo.WorkingDirectory = @"../../../ConsoleApp9\Children\bin\Debug\netcoreapp3.1";
                process.StartInfo.FileName = @"../../../ConsoleApp9\Children\bin\Debug\netcoreapp3.1\Children.exe";
                process.Start();
                process.WaitForExit();
            }).Start();


            // 子进程启动需要一点时间
            Thread.Sleep(TimeSpan.FromSeconds(1));

            // 获取互斥体
            bool firstInstance;
            m = new Mutex(true, name, out firstInstance);

            // 说明子进程还在运行
            if (!firstInstance)
            {
                // 等待子进程运行结束
                Console.WriteLine("等待子进程运行结束");
                m.WaitOne();
                Console.WriteLine("子进程运行结束，程序将在3秒后自动退出");
                m.ReleaseMutex();
                Thread.Sleep(TimeSpan.FromSeconds(3));
                return;
            }
        }
    }
}

请将 Children 项目的程序文件路径，替换到 Parent 项目启动子进程的那部分字符串中。

然后启动 Parent.exe，可以观察到如下图的运行过程：

另外

构造函数中，如果为 name 指定 null 或空字符串，则将创建一个本地 Mutex 对象，只会在进程内有效。

Mutex 有些使用方法比较隐晦，可以参考 https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.mutex.-ctor?view=netcore-3.1#System_Threading_Mutex__ctor_System_Boolean_

另外打开互斥体，请参考

https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.mutex.openexisting?view=netcore-3.1

https://docs.microsoft.com/zh-cn/dotnet/api/system.threading.mutex.tryopenexisting?view=netcore-3.1

到此这篇关于C#多线程系列之进程同步Mutex类的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持编程网。

点击免费下载>>软考高级考试备考技巧/历年真题/备考精华资料

--结束END--

本文标题: C#多线程系列之进程同步Mutex类

本文链接: https://www.lsjlt.com/news/138997.html(转载时请注明来源链接)

有问题或投稿请发送至: 邮箱/279061341@qq.com QQ/279061341

本篇文章演示代码以及资料文档资料下载

下载Word文档到电脑，方便收藏和打印～

下载Word文档

去做题

猜你喜欢

C#多线程系列之进程同步Mutex类

Mutex 中文为互斥，Mutex 类叫做互斥锁。它还可用于进程间同步的同步基元。 Mutex 跟 lock 相似，但是 Mutex 支持多个进程。Mutex 大约比 lock 慢 ...

99+

2022-11-13
C#多线程之线程同步

一、前言我们先来看下面一个例子： using System; using System.Threading; namespace ThreadSynchDemo { cl...

99+

2022-11-13
C#多线程之线程同步WaitHandle

一、引言在前面的文章中，我们是使用“锁”的方式实现了线程间的通信，这种通信方式比较笨重。除了锁之外，.NET中还提供了一些线程间更自由通讯的工具，他们提供了...

99+

2022-11-13
C#多线程系列之线程池

目录线程池ThreadPool 常用属性和方法线程池说明和示例线程池线程数线程池线程数说明不支持的线程池异步委托任务取消功能计时器线程池线程池全称为托管线程池，线程池受 .NET ...

99+

2022-11-13
C++多线程之使用Mutex和Critical_Section

在C++中，我们可以使用互斥锁（Mutex）和临界区（Critical Section）来实现多线程同步。**Mutex：**互斥锁...

99+

2023-09-11

C++
C#的进程同步Mutex类使用实例分析

这篇文章主要介绍“C#的进程同步Mutex类使用实例分析”，在日常操作中，相信很多人在C#的进程同步Mutex类使用实例分析问题上存在疑惑，小编查阅了各式资料，整理出简单好用的操作方法，希望对大家解答”C#的进程同步Mutex类使用实例分析...

99+

2023-06-29
C#多线程系列之线程通知

AutoRestEvent 类用于从一个线程向另一个线程发送通知。微软文档是这样介绍的：表示线程同步事件在一个等待线程释放后收到信号时自动重置。其构造函数只有一个：构造函数里面...

99+

2022-11-13
C#多线程系列之线程等待

目录前言volatile 关键字三种常用等待再说自旋和阻塞SpinWait 结构属性和方法自旋示例新的实现SpinLock 结构属性和方法示例等待性能对比前言 volatile 关键...

99+

2022-11-13
C++ 多线程之互斥量(mutex)详解

目录std::mutexstd::recursive_mutexstd::time_mutexstd::recursive_timed_mutexstd::shared_mutexs...

99+

2022-11-13
C#多线程系列之线程完成数

解决一个问题假如，程序需要向一个 Web 发送 5 次请求，受网路波动影响，有一定几率请求失败。如果失败了，就需要重试。示例代码如下： class Program ...

99+

2022-11-13
C#多线程系列之多线程锁lock和Monitor

目录1，Locklock 原型lock 编写实例2，Monitor怎么用呢解释一下示例设置获取锁的时效1，Lock lock 用于读一个引用类型进行加锁，同一时刻内只有一个线程能够访...

99+

2022-11-13
C#多线程系列之多阶段并行线程

前言这一篇，我们将学习用于实现并行任务、使得多个线程有序同步完成多个阶段的任务。应用场景主要是控制 N 个线程(可随时增加或减少执行的线程)，使得多线程在能够在 M 个阶段中保持...

99+

2022-11-13
C#多线程系列之手动线程通知

区别与示例 AutoResetEvent 和 ManualResetEvent 十分相似。两者之间的区别，在于前者是自动(Auto)，后者是手动(Manua)。你可以先运行下面的示...

99+

2022-11-13
Java多线程之线程同步

volatile 先看个例子 class Test { // 定义一个全局变量 private boolean isRun = true; // 从主线程调...

99+

2022-11-12
C#多线程系列之读写锁

本篇的内容主要是介绍 ReaderWriterLockSlim 类，来实现多线程下的读写分离。 ReaderWriterLockSlim ReaderWriterLock 类：定义支...

99+

2022-11-13
Java多线程之同步工具类CyclicBarrier

目录1 CyclicBarrier方法说明2 CyclicBarrier实例3 CyclicBarrier源码解析CyclicBarrier构造函数 await方法 nextGene...

99+

2022-11-12
Java多线程之同步工具类CountDownLatch

目录1 CountDownLatch主要方法2 CountDownLatch使用例子3 CountDownLatch源码分析构造函数countDown方法countDown方法的内部...

99+

2022-11-12
Java多线程之同步工具类Exchanger

目录1 Exchanger 介绍2 Exchanger 实例exchange等待超时 3 实现原理1 Exchanger 介绍前面分别介绍了CyclicBarrier、CountD...

99+

2022-11-12
C#多线程系列之原子操作

目录知识点竞争条件线程同步CPU时间片和上下文切换阻塞内核模式和用户模式Interlocked类1，出现问题2，Interlocked.Increment()3，Interlocke...

99+

2022-11-13
C++多线程之使用Mutex的方法是什么

在C++中使用Mutex（互斥锁）来实现多线程同步的方法如下：1. 包含头文件：首先要包含头文件 ``。2. 创建Mutex对象：使...

99+

2023-09-14

C++