C#多线程(4):进程同步Mutex类

简介:

C#多线程(4):进程同步Mutex类

目录
Mutex 类
构造函数和方法
系统只能运行一个程序的实例
解释一下上面的示例
接替运行
进程同步示例
另外
Mutex 类
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.cnblogs.com/suntp/p/8258488.html

接替运行
这里要实现,当同时点击一个程序时,只能有一个实例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()。

进程同步示例
这里我们实现一个这样的场景:

父进程 Parant 启动子进程 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));
        }
    }
}

}

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

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

namespace Parant
{

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 项目的程序文件路径,替换到 Parant 项目启动子进程的那部分字符串中。

然后启动 Parant.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

到目前为止,我们学习了排他锁 lock、Monitor、Mutex。下一篇我们将来学习非排他锁定结构的Semaphore和SemaphoreSlim 。

原文地址https://www.cnblogs.com/whuanle/p/12726724.html

相关文章
|
13天前
|
并行计算 数据处理 调度
Python中的并发编程:探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程,通过对比分析它们的工作原理、适用场景及性能差异,揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念,随后详细阐述了Python中多线程与多进程的实现机制,包括GIL(全局解释器锁)对多线程的影响以及多进程的独立内存空间特性。最后,通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
|
14天前
|
安全 Java
Java多线程集合类
本文介绍了Java中线程安全的问题及解决方案。通过示例代码展示了使用`CopyOnWriteArrayList`、`CopyOnWriteArraySet`和`ConcurrentHashMap`来解决多线程环境下集合操作的线程安全问题。这些类通过不同的机制确保了线程安全,提高了并发性能。
|
17天前
|
Linux 调度 C语言
深入理解操作系统:进程和线程的管理
【10月更文挑战第32天】本文旨在通过浅显易懂的语言和实际代码示例,带领读者探索操作系统中进程与线程的奥秘。我们将从基础知识出发,逐步深入到它们在操作系统中的实现和管理机制,最终通过实践加深对这一核心概念的理解。无论你是编程新手还是希望复习相关知识的资深开发者,这篇文章都将为你提供有价值的见解。
|
15天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
24 1
|
20天前
深入理解操作系统:进程与线程的管理
【10月更文挑战第30天】操作系统是计算机系统的核心,它负责管理计算机硬件资源,为应用程序提供基础服务。本文将深入探讨操作系统中进程和线程的概念、区别以及它们在资源管理中的作用。通过本文的学习,读者将能够更好地理解操作系统的工作原理,并掌握进程和线程的管理技巧。
36 2
|
21天前
|
调度 Python
深入浅出操作系统:进程与线程的奥秘
【10月更文挑战第28天】在数字世界的幕后,操作系统悄无声息地扮演着关键角色。本文将拨开迷雾,深入探讨操作系统中的两个基本概念——进程和线程。我们将通过生动的比喻和直观的解释,揭示它们之间的差异与联系,并展示如何在实际应用中灵活运用这些知识。准备好了吗?让我们开始这段揭秘之旅!
|
30天前
|
Java 开发者
在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中,创建线程的方法有两种:继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱,帮助你更好地理解和选择适合项目需求的线程创建方式。
19 3
|
30天前
|
Java
在Java多线程编程中,实现Runnable接口通常优于继承Thread类
【10月更文挑战第20天】在Java多线程编程中,实现Runnable接口通常优于继承Thread类。原因包括:1) Java只支持单继承,实现接口不受此限制;2) Runnable接口便于代码复用和线程池管理;3) 分离任务与线程,提高灵活性。因此,实现Runnable接口是更佳选择。
37 2
|
30天前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析:线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式:继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景,帮助读者更好地理解和掌握多线程编程技术,为复杂任务的高效处理奠定基础。
30 2
|
30天前
|
Java 开发者
Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南:介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点,重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
34 1