C# Threading: Mutual exclusion (via Mutex Class)
Observe the following faulty snippet
(don't use):
using System;
using System.Threading;
using System.IO;
class Program
{
static void Main(string[] args)
{
for (int i = 0; i < 3; i++)
{
Thread thread = new Thread(new ThreadStart(ThreadMain));
thread.Name = String.Concat("Thread - ", i);
thread.Start();
}
}
static void ThreadMain()
{
// Simulate Some work
Thread.Sleep(500);
// Access a shared resource / critical section
WriteToFile();
}
static void WriteToFile()
{
String ThreadName = Thread.CurrentThread.Name;
Console.WriteLine("{0} using resource", ThreadName);
try
{
using (StreamWriter sw = new StreamWriter("1.txt", true))
{
sw.WriteLine(ThreadName);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
}
What we've got here is three threads trying to write to a file, which
fails horribly since we cant concurrently write to the same file.
We need some kind of synchronization mechanism to ensure that our threads
access shared resources when appropriate.
In the .NET framework one of the solutions is to use the Mutex ("Mutual exclusion") class to aid us with this issue.
In the following snippet the issue gets resolved by adding a Mutex instance to it:
static Mutex mutex = new Mutex();
static void WriteToFile()
{
mutex.WaitOne();
String ThreadName = Thread.CurrentThread.Name;
Console.WriteLine("{0} using resource", ThreadName);
try
{
using (StreamWriter sw = new StreamWriter("1.txt", true))
{
sw.WriteLine(ThreadName);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
Console.WriteLine("{0} releasing resource", ThreadName);
mutex.ReleaseMutex();
}
The first thread that reaches the critical section (writing of the file) takes ownership
of the mutex - the other threads simply wait for the mutex to be released by the thread
that owns it - each taking ownership once its released etc etc etc.
Basically its like making a queue behind a resource and only one thread is allowed to use the resource at a time.
We do however get a more lightweight class in the .NET framework that provides mutual-exclusion as well, namely the
Monitor class (or lock statement).
What makes the Mutex class different (and more powerful) can be observed in the following snippet:
using System;
using System.Threading;
class Program
{
static void Main(string[] args)
{
bool createdNew;
using (Mutex mutex = new Mutex(true, "App", out createdNew))
{
if (!createdNew)
{
Console.WriteLine("Application already open");
return;
}
Console.WriteLine("Press any key to continue...");
Console.ReadKey();
}
}
}
Mutexes can be accessed system wide and across app domains & terminals, in the preceding snippet we prevent an user of opening multiple
instances of our process.
There are two types of Mutexes, local(unnamed) - which is only available within its parent process (like the first snippet) and global(named) which is
available system wide (like in the last snippet).
Additionally we can set the visibility of a global(named) mutex with regards to Terminal Services. If our named mutex starts with "Global\", it
becomes visible to all terminal sessions, if it starts with "Local\" its only available to the terminal session that created it.
Additional reading:
C# Threading: Mutual exclusion (via Monitor Class)
http://msdn.microsoft.com/en-us/library/system.threading.mutex.aspx
Posted by - Christoff Truter
Date - 2010-08-03 14:42:36
Comments
Post comment