From: 011netservice@gmail.com
Date: 2024-02-29
Subject: Mutex.txt

歡迎來信交流

摘要:

  Mutex: 互斥鎖
    A synchronization primitive that can also be used for interprocess synchronization.
	互斥鎖 可用於跨執行緒控制資源同步.

#### 使用備忘:
/*
跨執行緒互斥鎖, 同一時間只有一個執行緒可擁有.
呼叫 Mutex.ReleaseMutex() 可釋放.
呼叫 Mutext.WaitOne() 可等待釋放後, 自動擁有.
使用時必須注意 Mutex 在 release 期間可能會被 GC 回收. 

#### Locking: lock vs Mutex
https://www.albahari.com/threading/part2.aspx#_Locking
LockVsMutex.pdf


#### A synchronization primitive that can also be used for interprocess synchronization.
ref: https://dotblogs.com.tw/larrynung/2012/04/08/71353
使用時必須注意 Mutex 在 release 期間可能會被 GC 回收. 
解決方法為
1. 將 mutex 成為類別成員.
2. 使用 using 或 try/Catch 包住 mutex.
3. 正規使用 mutex: 加上 WaitOne().

每支程式以不同GUID當成Mutex名稱，可避免執行檔同名同姓的風險
static string appGuid = "{B19DAFCB-729C-43A6-8232-F3C31BB4E404}";
string appGuid = "{B19DAFCB-729C-43A6-8232-F3C31BB4E404}";

如果要做到跨Session唯一，名稱可加入"Global\"前綴字
即使用多個帳號透過Terminal Service登入系統
整台機器也只能執行一份
執行期間Mutex 必須一直存在, 才能整台機器也只能執行一份
using (Mutex m = new Mutex(false, "Global\\" + sAppGuid)) // CodeHelper: Mutex using with Global Guid.
{
    //檢查是否同名Mutex已存在(表示另一份程式正在執行)
    if (!m.WaitOne(0, false)) // CodeHelper
    {
        Console.WriteLine("Only one instance is allowed!");
        return;
    }

    // 程式處理邏輯
    Console.WriteLine("Press Enter to exit...");
    Console.ReadLine();
}
檢查是否同名Mutex已存在(表示另一份程式正在執行)

*/
		



ref
https://docs.microsoft.com/en-us/dotnet/api/system.threading.mutex.-ctor?view=netframework-4.0&f1url=%3FappId%3DDev16IDEF1%26l%3DEN-US%26k%3Dk(System.Threading.Mutex.%2523ctor);k(TargetFrameworkMoniker-.NETFramework,Version%253Dv4.0);k(DevLang-csharp)%26rd%3Dtrue

OVERLOADS
這5種建構式, 最好先讀懂再使用:
1. Mutex()	
Initializes a new instance of the Mutex class with default properties.

2. Mutex(Boolean)	
Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex.

3. Mutex(Boolean, String)	
Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex.

4. Mutex(Boolean, String, Boolean)	
Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex.

5. Mutex(Boolean, String, Boolean, MutexSecurity)	
Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, a Boolean variable that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex, and the access control security to be applied to the named mutex.

MS 有以下5個範例:

1 public Mutex ();
Initializes a new instance of the Mutex class with default properties.
public Mutex ();

The following code example shows how a local Mutex object is used to synchronize access to a protected resource. The thread that creates the mutex does not own it initially.
// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.
 
using System;
using System.Threading;

class Test
{
    // Create a new Mutex. The creating thread does not own the
    // Mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread myThread = new Thread(new ThreadStart(MyThreadProc));
            myThread.Name = String.Format("Thread{0}", i + 1);
            myThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void MyThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        mut.WaitOne();

        Console.WriteLine("{0} has entered the protected area", 
            Thread.CurrentThread.Name);

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

        Console.WriteLine("{0} is leaving the protected area\r\n", 
            Thread.CurrentThread.Name);
         
        // Release the Mutex.
        mut.ReleaseMutex();
    }
}
Remarks
Calling this constructor overload is the same as calling the Mutex(Boolean) constructor overload and specifying false for initial ownership of the mutex. That is, the calling thread does not own the mutex.

2 public Mutex (bool initiallyOwned);
Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex.
public Mutex (bool initiallyOwned);

The following code example shows how a local Mutex object is used to synchronize access to a protected resource. The thread that creates the Mutex owns it initially.
using System;
using System.Threading;

class Test
{
    // Create a new Mutex. The creating thread owns the Mutex.
    private static Mutex mut = new Mutex(true);
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread myThread = new Thread(new ThreadStart(MyThreadProc));
            myThread.Name = String.Format("Thread{0}", i + 1);
            myThread.Start();
        }

        // Wait one second before allowing other threads to
        // acquire the Mutex.
        Console.WriteLine("Creating thread owns the Mutex.");
        Thread.Sleep(1000);

        Console.WriteLine("Creating thread releases the Mutex.\r\n");
        mut.ReleaseMutex();
    }

    private static void MyThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        mut.WaitOne();

        Console.WriteLine("{0} has entered the protected area", 
            Thread.CurrentThread.Name);

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

        Console.WriteLine("{0} is leaving the protected area\r\n", 
            Thread.CurrentThread.Name);
         
        // Release the Mutex.
        mut.ReleaseMutex();
    }
}
// The example displays output like the following:
//       Creating thread owns the Mutex.
//       Creating thread releases the Mutex.
//       
//       Thread1 has entered the protected area
//       Thread1 is leaving the protected area
//       
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area


3 public Mutex (bool initiallyOwned, string name);
Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex.
public Mutex (bool initiallyOwned, string name);

The following example shows how a named mutex is used to signal between threads running in two separate processes.

Run this program from two or more command windows. Each process creates a Mutex object that represents the named mutex MyMutex. The named mutex is a system object whose lifetime is bounded by the lifetimes of the Mutex objects that represent it. The named mutex is created when the first process creates its Mutex object; in this example, the named mutex is owned by the first process that runs the program. The named mutex is destroyed when all the Mutex objects that represent it have been released.

The constructor overload used in this example cannot tell the calling thread whether initial ownership of the named mutex was granted. You should not use this constructor to request initial ownership unless you can be certain that the thread will create the named mutex.

using System;
using System.Threading;

public class Test
{
    public static void Main()
    {
        // Create the named mutex. Only one system object named 
        // "MyMutex" can exist; the local Mutex object represents 
        // this system object, regardless of which process or thread
        // caused "MyMutex" to be created.
        Mutex m = new Mutex(false, "MyMutex");
        
        // Try to gain control of the named mutex. If the mutex is 
        // controlled by another thread, wait for it to be released.        
        Console.WriteLine("Waiting for the Mutex.");
        m.WaitOne();

        // Keep control of the mutex until the user presses
        // ENTER.
        Console.WriteLine("This application owns the mutex. " +
            "Press ENTER to release the mutex and exit.");
        Console.ReadLine();

        m.ReleaseMutex();
    }
}
Remarks
The name may be prefixed with Global\ or Local\ to specify a namespace. When the Global namespace is specified, the synchronization object may be shared with any processes on the system. When the Local namespace is specified, which is also the default when no namespace is specified, the synchronization object may be shared with processes in the same session. On Windows, a session is a login session, and services typically run in a different non-interactive session. On Unix-like operating systems, each shell has its own session. Session-local synchronization objects may be appropriate for synchronizing between processes with a parent/child relationship where they all run in the same session. For more information about synchornization object names on Windows, see Object Names.

If a name is provided and a synchronization object of the requested type already exists in the namespace, the existing synchronization object is used. If a synchronization object of a different type already exists in the namespace, a WaitHandleCannotBeOpenedException is thrown. Otherwise, a new synchronization object is created.

If name is not null and initiallyOwned is true, the calling thread owns the mutex only if the named system mutex was created as a result of this call. Since there is no mechanism for determining whether the named system mutex was created, it is better to specify false for initiallyOwned when calling this constructor overload. You can use the Mutex(Boolean, String, Boolean) constructor if you need to determine initial ownership.

This constructor initializes a Mutex object that represents a named system mutex. You can create multiple Mutex objects that represent the same named system mutex.

If the named mutex has already been created with access control security, and the caller does not have MutexRights.FullControl, an exception is thrown. To open an existing named mutex with only those permissions needed for synchronizing thread activities, see the OpenExisting method.

If you specify null or an empty string for name, a local mutex is created, as if you had called the Mutex(Boolean) constructor. In this case, createdNew is always true.
若參數 name 為 null , 或 empty, 則會建立為 local mutex.
同樣的, 呼叫建構式 Mutex(Boolean), 也是同樣的結果.
這樣的情況下, out 參數 createdNew 將會永遠輸出 true.

Because they are system-wide, named mutexes can be used to coordinate resource use across process boundaries.

The backslash (\) is a reserved character in a mutex name. Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

4 public Mutex (bool initiallyOwned, string name, out bool createdNew);
Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex.
public Mutex (bool initiallyOwned, string name, out bool createdNew);

The following code example shows how a named mutex is used to signal between processes or threads. Run this program from two or more command windows. Each process creates a Mutex object that represents the named mutex "MyMutex". The named mutex is a system object. In this example, its lifetime is bounded by the lifetimes of the Mutex objects that represent it. The named mutex is created when the first process creates its local Mutex object, and destroyed when all the Mutex objects that represent it have been released. The named mutex is initially owned by the first process. The second process and any subsequent processes wait for earlier processes to release the named mutex.

// This example shows how a named mutex is used to signal between
// processes or threads.
// Run this program from two (or more) command windows. Each process
// creates a Mutex object that represents the named mutex "MyMutex".
// The named mutex is a system object whose lifetime is bounded by the
// lifetimes of the Mutex objects that represent it. The named mutex
// is created when the first process creates its local Mutex; in this
// example, the named mutex is owned by the first process. The named 
// mutex is destroyed when all the Mutex objects that represent it
// have been released. 
// The second process (and any subsequent process) waits for earlier
// processes to release the named mutex.

using System;
using System.Threading;

public class Test
{
    public static void Main()
    {
        // Set this variable to false if you do not want to request 
        // initial ownership of the named mutex.
        bool requestInitialOwnership = true;
        bool mutexWasCreated;

        // Request initial ownership of the named mutex by passing
        // true for the first parameter. Only one system object named 
        // "MyMutex" can exist; the local Mutex object represents 
        // this system object. If "MyMutex" is created by this call,
        // then mutexWasCreated contains true; otherwise, it contains
        // false.
        Mutex m = new Mutex(requestInitialOwnership, 
                            "MyMutex", 
                            out mutexWasCreated);
        
        // This thread owns the mutex only if it both requested 
        // initial ownership and created the named mutex. Otherwise,
        // it can request the named mutex by calling WaitOne.
        if (!(requestInitialOwnership && mutexWasCreated))
        {
            Console.WriteLine("Waiting for the named mutex.");
            m.WaitOne();
        }

        // Once the process has gained control of the named mutex,
        // hold onto it until the user presses ENTER.
        Console.WriteLine("This process owns the named mutex. " +
            "Press ENTER to release the mutex and exit.");
        Console.ReadLine();

        // Call ReleaseMutex to allow other threads to gain control
        // of the named mutex. If you keep a reference to the local
        // Mutex, you can call WaitOne to request control of the 
        // named mutex.
        m.ReleaseMutex();
    }
}

he name may be prefixed with Global\ or Local\ to specify a namespace. When the Global namespace is specified, the synchronization object may be shared with any processes on the system. When the Local namespace is specified, which is also the default when no namespace is specified, the synchronization object may be shared with processes in the same session. On Windows, a session is a login session, and services typically run in a different non-interactive session. On Unix-like operating systems, each shell has its own session. Session-local synchronization objects may be appropriate for synchronizing between processes with a parent/child relationship where they all run in the same session. For more information about synchornization object names on Windows, see Object Names.

If a name is provided and a synchronization object of the requested type already exists in the namespace, the existing synchronization object is used. If a synchronization object of a different type already exists in the namespace, a WaitHandleCannotBeOpenedException is thrown. Otherwise, a new synchronization object is created.

If name is not null and initiallyOwned is true, the calling thread owns the named mutex only if createdNew is true after the call. Otherwise the thread can request the mutex by calling the WaitOne method.

This constructor initializes a Mutex object that represents a named system mutex. You can create multiple Mutex objects that represent the same named system mutex.

If the named mutex has already been created with access control security, and the caller does not have MutexRights.FullControl rights, an exception is thrown. To open an existing named mutex with only those permissions needed for synchronizing thread activities, see the OpenExisting method.

If you specify null or an empty string for name, a local mutex is created, as if you had called the Mutex(Boolean) constructor. In this case, createdNew is always true.
若參數 name 為 null , 或 empty, 則會建立為 local mutex.
同樣的, 呼叫建構式 Mutex(Boolean), 也是同樣的結果.
這樣的情況下, out 參數 createdNew 將會永遠輸出 true.

Because they are system-wide, named mutexes can be used to coordinate resource use across process boundaries.



5 [System.Security.SecurityCritical]
public Mutex (bool initiallyOwned, string name, out bool createdNew, System.Security.AccessControl.MutexSecurity mutexSecurity);

Examples
The following code example demonstrates the cross-process behavior of a named mutex with access control security. The example uses the OpenExisting(String) method overload to test for the existence of a named mutex.

If the mutex does not exist, it is created with initial ownership and access control security that denies the current user the right to use the mutex, but grants the right to read and change permissions on the mutex.

If you run the compiled example from two command windows, the second copy will throw an access violation exception on the call to OpenExisting(String). The exception is caught, and the example uses the OpenExisting(String, MutexRights) method overload to open the mutex with the rights needed to read and change the permissions.

After the permissions are changed, the mutex is opened with the rights required to enter and release it. If you run the compiled example from a third command window, it runs using the new permissions.

using System;
using System.Threading;
using System.Security.AccessControl;

internal class Example
{
    internal static void Main()
    {
        const string mutexName = "MutexExample4";

        Mutex m = null;
        bool doesNotExist = false;
        bool unauthorized = false;

        // The value of this variable is set by the mutex
        // constructor. It is true if the named system mutex was
        // created, and false if the named mutex already existed.
        //
        bool mutexWasCreated = false;

        // Attempt to open the named mutex.
        try
        {
            // Open the mutex with (MutexRights.Synchronize |
            // MutexRights.Modify), to enter and release the
            // named mutex.
            //
            m = Mutex.OpenExisting(mutexName);
        }
        catch(WaitHandleCannotBeOpenedException)
        {
            Console.WriteLine("Mutex does not exist.");
            doesNotExist = true;
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
            unauthorized = true;
        }

        // There are three cases: (1) The mutex does not exist.
        // (2) The mutex exists, but the current user doesn't 
        // have access. (3) The mutex exists and the user has
        // access.
        //
        if (doesNotExist)
        {
            // The mutex does not exist, so create it.

            // Create an access control list (ACL) that denies the
            // current user the right to enter or release the 
            // mutex, but allows the right to read and change
            // security information for the mutex.
            //
            string user = Environment.UserDomainName + "\\"
                + Environment.UserName;
            MutexSecurity mSec = new MutexSecurity();

            MutexAccessRule rule = new MutexAccessRule(user, 
                MutexRights.Synchronize | MutexRights.Modify, 
                AccessControlType.Deny);
            mSec.AddAccessRule(rule);

            rule = new MutexAccessRule(user, 
                MutexRights.ReadPermissions | MutexRights.ChangePermissions,
                AccessControlType.Allow);
            mSec.AddAccessRule(rule);

            // Create a Mutex object that represents the system
            // mutex named by the constant 'mutexName', with
            // initial ownership for this thread, and with the
            // specified security access. The Boolean value that 
            // indicates creation of the underlying system object
            // is placed in mutexWasCreated.
            //
            m = new Mutex(true, mutexName, out mutexWasCreated, mSec);

            // If the named system mutex was created, it can be
            // used by the current instance of this program, even 
            // though the current user is denied access. The current
            // program owns the mutex. Otherwise, exit the program.
            // 
            if (mutexWasCreated)
            {
                Console.WriteLine("Created the mutex.");
            }
            else
            {
                Console.WriteLine("Unable to create the mutex.");
                return;
            }
        }
        else if (unauthorized)
        {
            // Open the mutex to read and change the access control
            // security. The access control security defined above
            // allows the current user to do this.
            //
            try
            {
                m = Mutex.OpenExisting(mutexName, 
                    MutexRights.ReadPermissions | MutexRights.ChangePermissions);

                // Get the current ACL. This requires 
                // MutexRights.ReadPermissions.
                MutexSecurity mSec = m.GetAccessControl();
                
                string user = Environment.UserDomainName + "\\"
                    + Environment.UserName;

                // First, the rule that denied the current user 
                // the right to enter and release the mutex must
                // be removed.
                MutexAccessRule rule = new MutexAccessRule(user, 
                     MutexRights.Synchronize | MutexRights.Modify,
                     AccessControlType.Deny);
                mSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new MutexAccessRule(user, 
                    MutexRights.Synchronize | MutexRights.Modify,
                    AccessControlType.Allow);
                mSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // MutexRights.ChangePermissions.
                m.SetAccessControl(mSec);

                Console.WriteLine("Updated mutex security.");

                // Open the mutex with (MutexRights.Synchronize 
                // | MutexRights.Modify), the rights required to
                // enter and release the mutex.
                //
                m = Mutex.OpenExisting(mutexName);
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unable to change permissions: {0}",
                    ex.Message);
                return;
            }
        }

        // If this program created the mutex, it already owns
        // the mutex.
        //
        if (!mutexWasCreated)
        {
            // Enter the mutex, and hold it until the program
            // exits.
            //
            try
            {
                Console.WriteLine("Wait for the mutex.");
                m.WaitOne();
                Console.WriteLine("Entered the mutex.");
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unauthorized access: {0}", ex.Message);
            }
        }

        Console.WriteLine("Press the Enter key to exit.");
        Console.ReadLine();
        m.ReleaseMutex();
        m.Dispose();
    }
}

Remarks
The name may be prefixed with Global\ or Local\ to specify a namespace. When the Global namespace is specified, the synchronization object may be shared with any processes on the system. When the Local namespace is specified, which is also the default when no namespace is specified, the synchronization object may be shared with processes in the same session. On Windows, a session is a login session, and services typically run in a different non-interactive session. On Unix-like operating systems, each shell has its own session. Session-local synchronization objects may be appropriate for synchronizing between processes with a parent/child relationship where they all run in the same session. For more information about synchornization object names on Windows, see Object Names.

If a name is provided and a synchronization object of the requested type already exists in the namespace, the existing synchronization object is used. If a synchronization object of a different type already exists in the namespace, a WaitHandleCannotBeOpenedException is thrown. Otherwise, a new synchronization object is created.

If name is not null and initiallyOwned is true, the calling thread owns the named mutex only if createdNew is true after the call. Otherwise the thread can request the mutex by calling the WaitOne method.

Use this constructor to apply access control security to a named system mutex when it is created, preventing other code from taking control of the mutex.

This constructor initializes a Mutex object that represents a named system mutex. You can create multiple Mutex objects that represent the same named system mutex.

If the named system mutex does not exist, it is created with the specified access control security. If the named mutex exists, the specified access control security is ignored.

 Note

The caller has full control over the newly created Mutex object even if mutexSecurity denies or fails to grant some access rights to the current user. However, if the current user attempts to get another Mutex object to represent the same named mutex, using either a constructor or the OpenExisting method, Windows access control security is applied.

If the named mutex has already been created with access control security, and the caller does not have MutexRights.FullControl, an exception is thrown. To open an existing named mutex with only those permissions needed for synchronizing thread activities, see the OpenExisting method.

If you specify null or an empty string for name, a local mutex is created, as if you had called the Mutex(Boolean) constructor. In this case, createdNew is always true.
若參數 name 為 null , 或 empty, 則會建立為 local mutex.
同樣的, 呼叫建構式 Mutex(Boolean), 也是同樣的結果.
這樣的情況下, out 參數 createdNew 將會永遠輸出 true.

Because they are system-wide, named mutexes can be used to coordinate resource use across process boundaries.

 Note

On a server that is running Terminal Services, a named system mutex can have two levels of visibility. If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". Within a terminal server session, two mutexes whose names differ only by their prefixes are separate mutexes, and both are visible to all processes in the terminal server session. That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

The backslash (\) is a reserved character in a mutex name. Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.



---------
  // Create a new Mutex. The creating thread does not own the mutex.
  private static Mutex mut = new Mutex();

  // Wait until it is safe to enter.
  // Blocks the current thread until the current WaitHandle receives a signal. (Inherited from WaitHandle)
  Console.WriteLine("{0} is requesting the mutex", Thread.CurrentThread.Name);
  mut.WaitOne();
		
  // Releases the Mutex once.
  mut.ReleaseMutex();
  
  // 注意要 Dispose() 乾淨
  mut.Dispose();
 
  // 以下範例, 可確保資源同步, 同一時間內只會有一個執行緒進入執行. 
  // This method represents a resource that must be synchronized
  // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter, and do not enter if the request times out.
        Console.WriteLine("{0} is requesting the mutex", Thread.CurrentThread.Name);
        if (mut.WaitOne(1000)) {
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name);
   
           // Place code to access non-reentrant resources here.
   
           // Simulate some work.
           Thread.Sleep(5000);
   
           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name);
   
           // Release the Mutex.
              mut.ReleaseMutex();
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name);
        }
        else {
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name);
        }
    }
  

----------
20210430
http://noteofisabella.blogspot.com/2019/03/c-threadmutexsemaphore.html

C# 執行緒(Thread)的Mutex及Semaphore探討
Mutex
作用在不同Process之間，同一時間內只授予一個Thread在共享資源的獨佔訪問。就好像是馬桶一樣，一次只能有一個人用，下一個想用馬桶的人只能等待。
 Semaphore
限制在同一時間內，允許訪問共享資源的Thread數量上限。就像百貨公司的廁所一樣，假設共有10間，一次最多就只能10個人同時上廁所，其餘想上廁所的人就得排隊等待。

以下是 Mutex範例：

using System;
using System.Threading;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            // ** *******************
            // * Thread的Mutex機制
            // * ********************
            string mutexName = "互斥量";
            using (var mutex = new Mutex(false, mutexName))
            {
                if (mutex.WaitOne(TimeSpan.FromSeconds(5), false))
                {
                    Console.WriteLine("占用一下");
                    Console.ReadLine();
                    mutex.ReleaseMutex();
                }
                else
                {
                    Console.WriteLine("我搶不到");
                }
            }
            Console.WriteLine("Hello World!");
            Console.ReadLine();
        }
    }
}

同時執行兩個Process時，第一個Process會看到占用一下，第二個Process會看到我搶不到，



以下是 Semaphore範例：

using System;
using System.Threading;

namespace ConsoleApp1
{
    class Program
    {
        static SemaphoreSlim _semaphoreSlim = new SemaphoreSlim(3);

        /// <summary>
        /// 在上廁所
        /// </summary>
        /// <param name="seconds"></param>
        static void Toilet(int seconds)
        {
            Console.WriteLine($"{Thread.CurrentThread.Name}等待中");
            _semaphoreSlim.Wait();
            Console.WriteLine($"{Thread.CurrentThread.Name}上廁所");
            Thread.Sleep(TimeSpan.FromSeconds(seconds));
            Console.WriteLine($"{Thread.CurrentThread.Name}上完了！");
            _semaphoreSlim.Release();
        }

        static void Main(string[] args)
        {
            // 假设廁所只有3個，但有5人要上廁所，所以有2位需要等待
            for (int i = 0; i < 5; i++)
            {
                Thread t = new Thread(() => {
                    Toilet(new Random().Next(2, 4));
                });
                t.Name = $"t{i}";
                t.Start();
            }

            Console.ReadKey();
        }
    }
}

執行結果如下：
廁所有三間，一開始 t0, t1, t4先上廁所，等 t0上完廁所了，t2才進入上廁所狀態。


----------
20210430

ref:
https://dotblogs.com.tw/larrynung/2012/04/08/71353

[C#]使用Mutex實現單一程式執行個體的注意事項

相信大家都知道在.NET程式中若要實現單一程式執行個體，一般來說有幾種方法，像是去判斷是否已經有開啟的Process是相同的程式、用Mutex與Semaphore之類的技術來判斷是否程式正在開啟。但是很多網路上的文章都忽略了在用Mutex實現單一程式執行個體時，其實會有些必須要注意的地方，導致於在實際運用上沒有發揮到該有的效果。

 

以一個簡單的例子來看，一般我們在網路上常看到的使用方式大概就像下面的程式碼片段類似，建構Mutex時就會回傳該Mutex是否已經存在，利用該回傳值來決定程式應該繼續開啟還是關閉。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Windows.Forms;
using System.Threading;

namespace WindowsFormsApplication10
{
	static class Program
	{
		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main()
		{
			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);

			Boolean bCreatedNew;

			//Create a new mutex using specific mutex name
			Mutex m = new Mutex(false, "myUniqueName", out bCreatedNew);

			if (bCreatedNew)
				Application.Run(new Form1());
		}
	}
}
 

這樣的程式到底有什麼樣的問題呢？有興趣的可以試著建置Release的程式看看，其實這樣的程式在某些情況下會在Release模式下失效，Debug的運作卻是正常的，若試不出來的可以再加上個GC.Collect試試，會更容易重現。

			...
			Boolean bCreatedNew;

			//Create a new mutex using specific mutex name
			Mutex m = new Mutex(false, "myUniqueName", out bCreatedNew);

			GC.Collect();

			if (bCreatedNew)
				Application.Run(new Form1());
			...
 

之所以會有這樣的問題，是因為Mutex在Release模式下被GC給回收了，而Debug模式下因為便於開發人員除錯，據說有將GC的周期給拉長，所以不容易重現。那這樣的問題要怎麼樣解決呢？這邊筆者有整理了幾種方法。

 

一個方法就是把Mutex給拉出來成為類別成員。

		...
		static Mutex m;

		/// <summary>
		/// The main entry point for the application.
		/// </summary>
		[STAThread]
		static void Main()
		{
			Application.EnableVisualStyles();
			Application.SetCompatibleTextRenderingDefault(false);

			Boolean bCreatedNew;

			//Create a new mutex using specific mutex name
			m = new Mutex(false, "myUniqueName", out bCreatedNew);
			GC.Collect();

			if (bCreatedNew)
				Application.Run(new Form1());
		}
		...
 

另一個方法就是讓Mutex不要被GC回收掉，像是在程式最後明確呼叫Dispose，讓GC知道該Mutex仍在使用。

			...
			Boolean bCreatedNew;

			//Create a new mutex using specific mutex name
			Mutex m = new Mutex(false, "myUniqueName", out bCreatedNew);

			GC.Collect();

			if (bCreatedNew)
				Application.Run(new Form1());

			m.Dispose();
			...
 

也可以用using或是try...finally之類的語法將Mutex給hold住。

			...
			Boolean bCreatedNew;

			//Create a new mutex using specific mutex name
			using (Mutex m = new Mutex(false, "myUniqueName", out bCreatedNew))
			{
				GC.Collect();

				if (bCreatedNew)
					Application.Run(new Form1());
			}
			...
 

或是把Mutex的用法寫的比較正規一點，加上WaitOne與ReleaseMutex去明確控制Mutex的作用範圍。

			...
			Boolean bCreatedNew;

			//Create a new mutex using specific mutex name
			Mutex m = new Mutex(false, "myUniqueName", out bCreatedNew);

			m.WaitOne();
			GC.Collect();

			if (bCreatedNew)
				Application.Run(new Form1());

			m.ReleaseMutex();
			...


----------
20210219
 
        private readonly Mutex _mutex;
        private LiteEngine _engine;
        private int _stack = 0;

        public SharedEngine(EngineSettings settings)
        {
            _settings = settings;

            var name = Path.GetFullPath(settings.Filename).ToLower().Sha1();

            try
            {
#if NETFRAMEWORK
// net45, 
                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\\" + name + ".Mutex", out _, securitySettings);
#else
// netstandard1.3, netstandard2.0
                _mutex = new Mutex(false, "Global\\" + name + ".Mutex");
#endif
            }
            catch (NotSupportedException ex)
            {
                throw new PlatformNotSupportedException("Shared mode is not supported in platforms that do not implement named mutex.", ex);
            }
        }

        /// <summary>
        /// Open database in safe mode
        /// </summary>
        private void OpenDatabase()
        {
            lock (_mutex)
            {
                _stack++;

                if (_stack == 1)
                {
                    try
                    {
                        _mutex.WaitOne();
                    }
                    catch (AbandonedMutexException) { }

                    try
                    {
                        _engine = new LiteEngine(_settings);
                    }
                    catch
                    {
                        _mutex.ReleaseMutex();
                        _stack = 0;
                        throw;
                    }
                }
            }
        }
		
		

        /// <summary>
        /// Dequeue stack and dispose database on empty stack
        /// </summary>
        private void CloseDatabase()
        {
            lock (_mutex)
            {
                _stack--;

                if (_stack == 0)
                {
                    _engine.Dispose();
                    _engine = null;

                    _mutex.ReleaseMutex();
                }
            }
        }
		
        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (_engine != null)
                {
                    _engine.Dispose();

                    _mutex.ReleaseMutex();
                }
            }
        }



  
  #if NETFRAMEWORK
	for (net45, netstandard1.3)
                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\\" + name + ".Mutex", out _, securitySettings);
  #else
    for (netstandard2.0)
                _mutex = new Mutex(false, "Global\\" + name + ".Mutex");
  #endif
	


----------
20210113
This example shows how a local Mutex object is used to synchronize access to a protected resource. Because each calling thread is blocked until it acquires ownership of the mutex, it must call the ReleaseMutex method to release ownership of the mutex.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name);
        mut.WaitOne();

        Console.WriteLine("{0} has entered the protected area", 
                          Thread.CurrentThread.Name);

        // Place code to access non-reentrant resources here.

        // Simulate some work.
        Thread.Sleep(500);

        Console.WriteLine("{0} is leaving the protected area", 
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name);
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread2 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread3 is requesting the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
//       Thread3 has released the mutex
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       Thread2 has released the mutex


In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. If the time-out interval elapses, the method returns false, and the thread neither acquires the mutex nor gains access to the resource the mutex protects. The ReleaseMutex method is called only by the thread that acquires the mutex.

using System;
using System.Threading;

class Example
{
    // Create a new Mutex. The creating thread does not own the mutex.
    private static Mutex mut = new Mutex();
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        Example ex = new Example();
        ex.StartThreads();
    }

     private void StartThreads()
     {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

        // The main thread returns to Main and exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void ThreadProc()
    {
        for(int i = 0; i < numIterations; i++)
        {
            UseResource();
        }
    }

    // This method represents a resource that must be synchronized
    // so that only one thread at a time can enter.
    private static void UseResource()
    {
        // Wait until it is safe to enter, and do not enter if the request times out.
        Console.WriteLine("{0} is requesting the mutex", Thread.CurrentThread.Name);
        if (mut.WaitOne(1000)) {
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name);
   
           // Place code to access non-reentrant resources here.
   
           // Simulate some work.
           Thread.Sleep(5000);
   
           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name);
   
           // Release the Mutex.
              mut.ReleaseMutex();
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name);
        }
        else {
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name);
        }
    }

    ~Example()
    {
       mut.Dispose();
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread2 is requesting the mutex
//       Thread3 is requesting the mutex
//       Thread2 will not acquire the mutex
//       Thread3 will not acquire the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex

Remarks
When two or more threads need to access a shared resource at the same time, the system needs a synchronization mechanism to ensure that only one thread at a time uses the resource. Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. If a thread acquires a mutex, the second thread that wants to acquire that mutex is suspended until the first thread releases the mutex.

 Important

This type implements the IDisposable interface. When you have finished using the type, you should dispose of it either directly or indirectly. To dispose of the type directly, call its Dispose method in a try/catch block. To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

You can use the WaitHandle.WaitOne method to request ownership of a mutex. The calling thread blocks until one of the following occurs:

The mutex is signaled to indicate that it is not owned. When this happens, the WaitOne method returns true, and the calling thread assumes ownership of the mutex and accesses the resource protected by the mutex. When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. The first example in the Examples section illustrates this pattern.

The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. In this case, you should structure your code so that access to the resource that is protected by the mutex is denied to the calling thread. Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. The second example in the Examples section illustrates this pattern.

The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. By contrast, the Semaphore class does not enforce thread identity. A mutex can also be passed across application domain boundaries.

The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

Because the Mutex class inherits from WaitHandle, you can also call the static WaitHandle.WaitAll and WaitHandle.WaitAny methods to synchronize access to a protected resource.

If a thread terminates while owning a mutex, the mutex is said to be abandoned. The state of the mutex is set to signaled, and the next waiting thread gets ownership. Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. Before version 2.0 of the .NET Framework, no exception was thrown.

 Caution

An abandoned mutex often indicates a serious error in the code. When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. The next thread to request ownership of the mutex can handle this exception and proceed, if the integrity of the data structures can be verified.

In the case of a system-wide mutex, an abandoned mutex might indicate that an application has been terminated abruptly (for example, by using Windows Task Manager).

Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. A local mutex exists only within your process. It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Each unnamed Mutex object represents a separate local mutex.

Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. You can create multiple Mutex objects that represent the same named system mutex, and you can use the OpenExisting method to open an existing named system mutex.

 Note

On a server that is running Terminal Services, a named system mutex can have two levels of visibility. If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". Within a terminal server session, two mutexes whose names differ only by their prefixes are separate mutexes, and both are visible to all processes in the terminal server session. That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

The backslash (\) is a reserved character in a mutex name. Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.