Csharp/CSharp Tutorial/Thread/Mutex

Name a Mutex

using System;
using System.Threading;
class MainClass {

  public static void Main( string[] args ) {
    string mutexName = "MainClass";
    Mutex m = new Mutex( false, mutexName );
    for( ;; ) {
      m.WaitOne( );
      Console.WriteLine("Have Mutex");
      Console.WriteLine("Releasing");
      m.ReleaseMutex( );
    }
  }
}

Have Mutex
Releasing
Have Mutex
Releasing
...
...
^CTerminate batch job (Y/N)? n

Own a Mutex

using System;
using System.Threading;
class MainClass
{
    public static void Main()
    {
        bool ownsMutex;
        using (Mutex mutex =new Mutex(true, "MutexExample", out ownsMutex))
        {
            if (ownsMutex)
            {
                Console.WriteLine("Owned");
                mutex.ReleaseMutex();
            }
            else
            {
                Console.WriteLine("Another instance of this application " +
                    " already owns the mutex named MutexExample.");
            }
        }
    }
}

Owned

Threading with Mutex

using System;
using System.Collections;
using System.Threading;
class MainClass 
{
  public static ArrayList MyList = new ArrayList();
  private static Mutex MyMutex = new Mutex(false, "MyMutex");
  static void Main(string[] args)
  {
      Thread ThreadOne = new Thread(new ThreadStart(MutexExample));
    ThreadOne.Start();
  }
  protected static void MutexExample()
  {
    MyMutex.WaitOne();
    MyList.Add(" a value");
    MyMutex.ReleaseMutex();
  }
}

Use a Mutex to control a shared resource against two current threads

using System;  
using System.Threading;  
 
class MyCounter { 
  public static int count = 0; 
  public static Mutex MuTexLock = new Mutex(); 
} 
 
class IncThread {  
  public Thread thrd;  
  
  public IncThread() {  
    thrd = new Thread(this.run);  
    thrd.Start();  
  }  
  
  void run() {  
    Console.WriteLine("IncThread is waiting for the mutex."); 
 
    MyCounter.MuTexLock.WaitOne(); 
 
    Console.WriteLine("IncThread acquires the mutex."); 
    
    int num = 10;
    do {  
      Thread.Sleep(50);  
      MyCounter.count++;  
      Console.WriteLine("In IncThread, MyCounter.count is " + MyCounter.count);  
      num--; 
    } while(num > 0);  
  
    Console.WriteLine("IncThread releases the mutex.");   
 
    MyCounter.MuTexLock.ReleaseMutex(); 
  }  
}  
 
class DecThread {  
  public Thread thrd;  
  
  public DecThread() {  
    thrd = new Thread(new ThreadStart(this.run));  
    thrd.Start();  
  }  
  
  void run() {  
    Console.WriteLine("DecThread is waiting for the mutex."); 
 
    MyCounter.MuTexLock.WaitOne(); 
 
    Console.WriteLine("DecThread acquires the mutex."); 
 
    int num = 10;
    do {  
      Thread.Sleep(50);  
      MyCounter.count--;  
      Console.WriteLine("In DecThread, MyCounter.count is " + MyCounter.count);  
      num--; 
    } while(num > 0);  
  
    Console.WriteLine("DecThread releases the mutex.");  
 
    MyCounter.MuTexLock.ReleaseMutex(); 
  }  
}  
  
class MainClass {  
  public static void Main() {  
    IncThread mt1 = new IncThread();  
    DecThread mt2 = new DecThread();  
  
    mt1.thrd.Join(); 
    mt2.thrd.Join(); 
  }  
}

IncThread is waiting for the mutex.
IncThread acquires the mutex.
DecThread is waiting for the mutex.
In IncThread, MyCounter.count is 1
In IncThread, MyCounter.count is 2
In IncThread, MyCounter.count is 3
In IncThread, MyCounter.count is 4
In IncThread, MyCounter.count is 5
In IncThread, MyCounter.count is 6
In IncThread, MyCounter.count is 7
In IncThread, MyCounter.count is 8
In IncThread, MyCounter.count is 9
In IncThread, MyCounter.count is 10
IncThread releases the mutex.
DecThread acquires the mutex.
In DecThread, MyCounter.count is 9
In DecThread, MyCounter.count is 8
In DecThread, MyCounter.count is 7
In DecThread, MyCounter.count is 6
In DecThread, MyCounter.count is 5
In DecThread, MyCounter.count is 4
In DecThread, MyCounter.count is 3
In DecThread, MyCounter.count is 2
In DecThread, MyCounter.count is 1
In DecThread, MyCounter.count is 0
DecThread releases the mutex.

Use the Mutex object: WaitOne

using System;
using System.Threading;
class MainClass
{
  private static int Runs = 0;
  static Mutex mtx = new Mutex(false, "RunsMutex");
  public static void CountUp() 
  {
    while (Runs < 10)
    {
      // acquire the mutex
      mtx.WaitOne();
      int Temp = Runs;
      Temp++;
      Console.WriteLine(Thread.CurrentThread.Name + " " + Temp);
      Thread.Sleep(1000);
      Runs = Temp;
      // release the mutex
      mtx.ReleaseMutex();
    } 
  }
  public static void Main() 
  {
    Thread t2 = new Thread(new ThreadStart(CountUp));
    t2.Name = "t2";
    Thread t3 = new Thread(new ThreadStart(CountUp));
    t3.Name = "t3";
    t2.Start();
    t3.Start();
  }
}

t2 1
t3 2
t3 3
t3 4
t3 5
t3 6
t3 7
t3 8
t3 9
t3 10
t2 11