Run single instance of an application using Mutex

问题:

In order to allow only a single instance of an application running I\'m using mutex. The code is given below. Is this the right way to do it? Are there any flaws in the code?

How to show the already running application when user tries to open the application the second time. At present (in the code below), I\'m just displaying a message that another instance is already running.

    static void Main(string[] args)
    {
        Mutex _mut = null;

        try
        {
            _mut = Mutex.OpenExisting(AppDomain.CurrentDomain.FriendlyName);
        }
        catch
        {
             //handler to be written
        }

        if (_mut == null)
        {
            _mut = new Mutex(false, AppDomain.CurrentDomain.FriendlyName);
        }
        else
        {
            _mut.Close();
            MessageBox.Show(\"Instance already running\");

        }            
    }

回答1:

I did it this way once, I hope it helps:

bool createdNew;

Mutex m = new Mutex(true, \"myApp\", out createdNew);

if (!createdNew)
{
    // myApp is already running...
    MessageBox.Show(\"myApp is already running!\", \"Multiple Instances\");
    return;
}

回答2:

static void Main() 
{
  using(Mutex mutex = new Mutex(false, @\"Global\\\" + appGuid))
  {
    if(!mutex.WaitOne(0, false))
    {
       MessageBox.Show(\"Instance already running\");
       return;
    }

    GC.Collect();                
    Application.Run(new Form1());
  }
}

Source : http://odetocode.com/Blogs/scott/archive/2004/08/20/401.aspx

回答3:

I use this:

    private static Mutex _mutex;

    private static bool IsSingleInstance()
    {
        _mutex = new Mutex(false, _mutexName);

        // keep the mutex reference alive until the normal 
        //termination of the program
        GC.KeepAlive(_mutex);

        try
        {
            return _mutex.WaitOne(0, false);
        }
        catch (AbandonedMutexException)
        {
            // if one thread acquires a Mutex object 
            //that another thread has abandoned 
            //by exiting without releasing it

            _mutex.ReleaseMutex();
            return _mutex.WaitOne(0, false);
        }
    }


    public Form1()
    {
        if (!isSingleInstance())
        {
            MessageBox.Show(\"Instance already running\");
            this.Close();
            return;
        }

        //program body here
    }

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        if (_mutex != null)
        {
            _mutex.ReleaseMutex();
        }
    }    

回答4:

Have a look at this question

There is a link to this article: the misunderstood mutex where the usage of a mutex is explained.

回答5:

Check out the code sample shown on this page

In short, you use the overload Mutex ctor(bool, string, out bool) which tells you via an out parameter, whether you got ownership of the Named Mutex. If you\'re the first instance, this out param would contain true after the ctor is called - in which case you proceed as usual. If this param is false, it means another instance has already got ownership/is running, in which case you show an error message \"Another instance is already running.\" and then exit gracefully.

回答6:

Use app with timeout and security settings. I used my custom class:

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();
            }
        }
    }

and use it:

    private static void Main(string[] args)
    {
        try
        {
            const string appguid = \"{xxxxxxxx-xxxxxxxx}\";
            using (new SingleAppMutexControl(appguid))
            {

                Console.ReadLine();
            }
        }
        catch (System.TimeoutException)
        {
            Log.Warn(\"Application already runned\");
        }
        catch (Exception ex)
        {
            Log.Fatal(ex, \"Fatal Error on running\");
        }
    }

回答7:

Also this. Is using a Mutex to prevent multiple instances of the same program from running safe?