C# 浅析并行任务同步机制——Mutex类

一、Mutex类

       Mutex(mutual exclusion，互斥)，是.Net Frameworkt中提供跨多个进程同步访问的一个类。

       Mutex，继承与WaitHandle

       注：一次只能有一个线程访问互斥保护的同步代码区域

二、应用场景

       场景1：可以禁止同一应用程序启动两次。

    /// <summary>
    /// App.xaml 的交互逻辑
    /// </summary>
    public partial class App : Application
    {
        /// <summary>
        /// 当前应用程序不能启动两次。
        /// </summary>
        /// <param name="e"></param>
        protected override void OnStartup(StartupEventArgs e)
        {
            bool createNew;
            Mutex mutex = new Mutex(false, "SingletonDemo", out createNew);
            if (!createNew)
            {
                MessageBox.Show("应用已经启动，不能再次启动");
                Application.Current.Shutdown();
            }
            base.OnStartup(e);
        }
    }

这个是WPF，判断程序是否启动。

实际项目开发时，我这遇到了上述代码，不起作用。

这时需要将 Mutex创建为成员变量，不是局部变量如下

    /// <summary>
    /// App.xaml 的交互逻辑
    /// </summary>
    public partial class App : Application
    {
        Mutex mutex;  //声明为成员变量，可以解决问题
        /// <summary>
        /// 当前应用程序不能启动两次。
        /// </summary>
        /// <param name="e"></param>
        protected override void OnStartup(StartupEventArgs e)
        {
            base.OnStartup(e);
            bool createNew;
            mutex = new Mutex(false, "SingletonDemo", out createNew);
            if (!createNew)
            {
                MessageBox.Show("应用已经启动，不能再次启动。");
                Application.Current.Shutdown();
            }
           
        }
    }

场景2：跨进程访问

使用Mutex 的 

      WaitOne 阻止当前线程，直到当前WaitHandle收到信号 

      ReleaseMutex 释放Mutex一次

互斥进程1代码：

 class Program
    {
        static void Main(string[] args)
        {
            bool _isHaveY;
            var mutex = new Mutex(false, "Singlot", out _isHaveY);
            if (mutex.WaitOne())
            {
                try
                {
                    for (var i = 0; i < 10; i++)
                    {
                        WriteLine($"MutexDemoOne i = {i.ToString()};");
                        Thread.Sleep(3000);
                    }
                }
                finally
                {
                    mutex.ReleaseMutex();
                    WriteLine("MutexDemoOne mutext Realase");
                }
            }
            else
            {
                WriteLine("MutexDemoOne检测到Mutext互斥对象运行");
            }
            WriteLine("");
            ReadLine();
        }
    }

互斥进程2代码：

class Program
{
        static void Main(string[] args)
        {
            bool _isHaveY;
            var mutex = new Mutex(false, "Singlot", out _isHaveY);
            if (mutex.WaitOne())
            {
                try
                {
                    for (var i = 0; i < 10; i++)
                    {
                        WriteLine($"MutexDemoTwo i = {i.ToString()};");
                        Thread.Sleep(2000);
                    }
                }
                finally
                {
                    mutex.ReleaseMutex();
                    WriteLine("MutexDemoTwo mutext Realase");
                }
            }
            else
            {
                WriteLine("MutexDemoTwo检测到Mutext互斥对象运行");
            }
            WriteLine("");
            ReadLine();
        }
}

场景1和场景2，用到的是Mutex的三个参数的构造函数。想要构建两个进程互斥的应用，就是使互斥体名称相同，就是构造函数的第二个参数。