是否使用Mutex来防止同一程序的多个实例运行安全？

时间：2009-03-14 18:53:08

标签： c# winforms mutex single-instance

我正在使用此代码阻止我的程序的第二个实例同时运行，是否安全？

Mutex appSingleton = new System.Threading.Mutex(false, "MyAppSingleInstnceMutx");
if (appSingleton.WaitOne(0, false)) {
    Application.EnableVisualStyles();
    Application.SetCompatibleTextRenderingDefault(false);
    Application.Run(new MainForm());
    appSingleton.Close();
} else {
    MessageBox.Show("Sorry, only one instance of MyApp is allowed.");
}

我很担心，如果有什么东西抛出异常并且应用程序崩溃了Mutex仍然会被保留。这是真的吗？

11 个答案:

答案 0 :(得分：57)

为此目的使用Windows事件更为常见和方便。 E.g。

static EventWaitHandle s_event ;

bool created ;
s_event = new EventWaitHandle (false, 
    EventResetMode.ManualReset, "my program#startup", out created) ;
if (created) Launch () ;
else         Exit   () ;

当您的进程退出或终止时，Windows将为您关闭该事件，如果没有打开的句柄，则将其销毁。

已添加：要管理会话，请为事件（或互斥锁）名称使用Local\和Global\前缀。如果您的应用程序是每个用户，只需将一个适当受损的登录用户名称附加到事件名称。

答案 1 :(得分：39)

一般情况下，这是有效的。然而，魔鬼在细节中。

首先，您要关闭finally块中的互斥锁。否则，您的进程可能会突然终止并使其处于信号状态，例如异常。这将使未来的流程实例无法启动。

不幸的是，即使使用finally块，您也必须处理在不释放互斥锁的情况下终止进程的可能性。例如，如果用户通过TaskManager杀死进程，就会发生这种情况。您的代码中存在竞争条件，允许第二个进程在AbandonedMutexException调用中获得WaitOne。你需要一个恢复策略。

我鼓励您阅读the details of the Mutex class。使用它并不总是很简单。

扩大竞争条件的可能性：

可能会发生以下事件序列，这会导致应用程序的第二个实例抛出：

  1. 正常流程启动。
  2. 第二个进程启动并获取互斥锁的句柄，但在WaitOne调用之前被关闭。
  3. 进程＃1突然终止。由于进程＃2有句柄，因此不会破坏互斥锁。相反，它被设置为废弃状态。
  4. 第二个进程再次开始运行并获得AbanonedMutexException。

答案 2 :(得分：9)

您可以使用互斥锁，但首先请确保这确实是您想要的。

因为“避免多个实例”没有明确定义。这可能意味着

  1. 避免在同一个用户会话中启动多个实例，无论用户会话有多少个桌面，但允许多个实例同时为不同的用户会话运行。
  2. 避免在同一个桌面上启动多个实例，但只要每个实例位于单独的桌面中，就允许多个实例运行。
  3. 避免为同一个用户帐户启动多个实例，无论存在多少个桌面或此帐户下运行的会话，但允许多个实例同时运行在另一个用户帐户下运行的会话。
  4. 避免在同一台计算机上启动多个实例。这意味着无论任意数量的用户使用了多少台桌面，最多只能运行一个程序实例。

    5. 通过使用互斥锁，您基本上使用的是定义编号4。

答案 3 :(得分：9)

我使用这种方法，我认为它是安全的，因为如果任何应用程序都没有持有Mutex，那么它就会被销毁（如果它们最初不能创建Mutext，应用程序就会被终止）。这可能在'AppDomain-processes'中有相同或不同的作用（参见下面的链接）：

// Make sure that appMutex has the lifetime of the code to guard --
// you must keep it from being collected (and the finalizer called, which
// will release the mutex, which is not good here!).
// You can also poke the mutex later.
Mutex appMutex;

// In some startup/initialization code
bool createdNew;
appMutex = new Mutex(true, "mutexname", out createdNew);
if (!createdNew) {
  // The mutex already existed - exit application.
  // Windows will release the resources for the process and the
  // mutex will go away when no process has it open.
  // Processes are much more cleaned-up after than threads :)
} else {
  // win \o/
}

以上内容受到其他答案/评论中关于恶意程序可以坐在互斥锁上的注释的影响。这里不是问题。此外，在“本地”空间中创建了未加前缀的互斥锁。这可能是正确的事情。

请参阅：http://ayende.com/Blog/archive/2008/02/28/The-mysterious-life-of-mutexes.aspx - Jon Skeet附带; - ）

答案 4 :(得分：3)

在Windows上，终止进程会产生以下结果：

  • 流程中的所有剩余线程都标记为终止。
  • 释放该流程分配的所有资源。
  • 关闭所有内核对象。
  • 将从内存中删除进程代码。
  • 设置了流程退出代码。
  • 发出过程对象的信号。

互斥对象是内核对象，因此当进程终止时（在Windows中无论如何），进程持有的任何对象都会被关闭。

但是，请注意CreateMutex（）文档中的以下内容：

  

如果您使用命名互斥锁将应用程序限制为单个实例，则恶意用户可以在此之前创建此互斥锁，并阻止您的应用程序启动。

答案 5 :(得分：2)

是的，它是安全的，我建议使用以下模式，因为您需要确保始终释放Mutex。

using( Mutex mutex = new Mutex( false, "mutex name" ) )
{
    if( !mutex.WaitOne( 0, true ) )
    {
        MessageBox.Show("Unable to run multiple instances of this program.",
                        "Error",  
                        MessageBoxButtons.OK, 
                        MessageBoxIcon.Error);
    }
    else
    {
        Application.EnableVisualStyles();
        Application.SetCompatibleTextRenderingDefault(false);
        Application.Run(new MainForm());                  
    }
}

答案 6 :(得分：2)

这是代码段

public enum ApplicationSingleInstanceMode
{
    CurrentUserSession,
    AllSessionsOfCurrentUser,
    Pc
}

public class ApplicationSingleInstancePerUser: IDisposable
{
    private readonly EventWaitHandle _event;

    /// <summary>
    /// Shows if the current instance of ghost is the first
    /// </summary>
    public bool FirstInstance { get; private set; }

    /// <summary>
    /// Initializes 
    /// </summary>
    /// <param name="applicationName">The application name</param>
    /// <param name="mode">The single mode</param>
    public ApplicationSingleInstancePerUser(string applicationName, ApplicationSingleInstanceMode mode = ApplicationSingleInstanceMode.CurrentUserSession)
    {
        string name;
        if (mode == ApplicationSingleInstanceMode.CurrentUserSession)
            name = $"Local\\{applicationName}";
        else if (mode == ApplicationSingleInstanceMode.AllSessionsOfCurrentUser)
            name = $"Global\\{applicationName}{Environment.UserDomainName}";
        else
            name = $"Global\\{applicationName}";

        try
        {
            bool created;
            _event = new EventWaitHandle(false, EventResetMode.ManualReset, name, out created);
            FirstInstance = created;
        }
        catch
        {
        }
    }

    public void Dispose()
    {
        _event.Dispose();
    }
}

答案 7 :(得分：0)

如果要使用基于互斥锁的方法，则应该使用本地互斥锁restrict the approach to just the curent user's login session。并且还注意到该链接中关于使用互斥方法进行稳健资源处理的另一个重要警告。

有一点需要注意，当用户尝试启动第二个实例时，基于互斥锁的方法不允许您激活应用程序的第一个实例。

另一种方法是在第一个实例上使用PInvoke到FindWindow，然后是SetForegroundWindow。另一种方法是按名称检查您的流程：

Process[] processes = Process.GetProcessesByName("MyApp");
if (processes.Length != 1)
{
    return;
}

这两种替代方案都有一个假设的竞争条件，即应用程序的两个实例可以同时启动然后相互检测。这在实践中不太可能发生 - 事实上，在测试过程中我无法实现。

后两种替代方案的另一个问题是它们在使用终端服务时不起作用。

答案 8 :(得分：0)

使用具有超时和安全设置的应用程序，避免AbandonedMutexException。我使用了自定义类：

private class SingleAppMutexControl : IDisposable
    {
        private readonly Mutex _mutex;
        private readonly bool _hasHandle;

        public SingleAppMutexControl(string appGuid, int waitmillisecondsTimeout = 5000)
        {
            bool createdNew;
            var allowEveryoneRule = new MutexAccessRule(new SecurityIdentifier(WellKnownSidType.WorldSid, null),
                MutexRights.FullControl, AccessControlType.Allow);
            var securitySettings = new MutexSecurity();
            securitySettings.AddAccessRule(allowEveryoneRule);
            _mutex = new Mutex(false, "Global\\" + appGuid, out createdNew, securitySettings);
            _hasHandle = false;
            try
            {
                _hasHandle = _mutex.WaitOne(waitmillisecondsTimeout, false);
                if (_hasHandle == false)
                    throw new System.TimeoutException();
            }
            catch (AbandonedMutexException)
            {
                _hasHandle = true;
            }
        }

        public void Dispose()
        {
            if (_mutex != null)
            {
                if (_hasHandle)
                    _mutex.ReleaseMutex();
                _mutex.Dispose();
            }
        }
    }

并使用它：

    private static void Main(string[] args)
    {
        try
        {
            const string appguid = "{xxxxxxxx-xxxxxxxx}";
            using (new SingleAppMutexControl(appguid))
            {
                //run main app
                Console.ReadLine();
            }
        }
        catch (System.TimeoutException)
        {
            Log.Warn("Application already runned");
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, "Fatal Error on running");
        }
    }

答案 9 :(得分：0)

以下是我如何处理这个

在Program类中： 1.使用Process.GetCurrentProcess（）获取您的应用程序的System.Diagnostics.Process 2.使用Process.GetProcessesByName（thisProcess.ProcessName）逐步使用应用程序的当前名称收集打开的进程 3.检查每个进程。对于thisProcess.Id并且如果一个实例已经打开，那么至少1个将匹配name而不是Id，否则继续打开实例

using System.Diagnostics;

.....    

static void Main()
{
   Process thisProcess = Process.GetCurrentProcess();
   foreach(Process p in Process.GetProcessesByName(thisProcess.ProcessName))
   {
      if(p.Id != thisProcess.Id)
      {
         // Do whatever u want here to alert user to multiple instance
         return;
      }
   }
   // Continue on with opening application

完成此操作的一个不错的方法是将已经打开的实例呈现给用户，很可能他们不知道它是打开的，所以让我们向他们展示它。为此，我使用User32.dll将消息广播到Windows消息循环，一个自定义消息，我让我的应用程序在WndProc方法中监听它，如果它收到此消息，它将自己呈现给用户，表单.Show（）或诸如此类

答案 10 :(得分：0)

重要的是要记住，可以通过Microsoft sysinternals中的handle.exe之类的程序轻松查看此互斥体\事件，然后如果使用常量名称，可能会有邪恶的人使用它来阻止您的应用程序启动。

以下是Microsoft关于安全替代方案的一些建议：

但是，恶意用户可以先创建此互斥对象，然后再执行 阻止您的应用程序启动。为了防止这种情况， 创建一个随机命名的互斥体并存储名称，以便它只能 由授权用户获得。或者，您可以使用一个文件 以此目的。为了将您的应用程序限制为每个用户一个实例， 在用户的个人资料目录中创建一个锁定的文件。

从这里拍摄： https://docs.microsoft.com/en-us/sysinternals/downloads/handle

相关问题
最新问题