Information
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

Mutex Class

A synchronization primitive than can also be used for interprocess synchronization.

For a list of all members of this type, see Mutex Members.

System.Object
   System.MarshalByRefObject
      System.Threading.WaitHandle
         System.Threading.Mutex

[Visual Basic]
NotInheritable Public Class Mutex
   Inherits WaitHandle
[C#]
public sealed class Mutex : WaitHandle
[C++]
public __gc __sealed class Mutex : public WaitHandle
[JScript]
public class Mutex extends WaitHandle

Thread Safety

This type is safe for multithreaded operations.

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.

You can use WaitHandle.WaitOne to request ownership of a mutex. The thread that owns a mutex can request the same mutex in repeated calls to Wait without blocking its execution. However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex. If a thread terminates normally while owning a mutex, the state of the mutex is set to signaled and the next waiting thread gets ownership. If no one owns the mutex, the state of the mutex is signaled.

Example

[Visual Basic] 
' 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.
 
Imports System
Imports System.Threading
Imports Microsoft.VisualBasic

Class Test
    ' Create a new Mutex. The creating thread does not own the
    ' Mutex.
    Private Shared mut As New Mutex()
    Private Const numIterations As Integer = 1
    Private Const numThreads As Integer = 3

    Shared Sub Main()
        ' Create the threads that will use the protected resource.
        Dim i As Integer
        For i = 1 To numThreads
            Dim myThread As New Thread(AddressOf MyThreadProc)
            myThread.Name = [String].Format("Thread{0}", i)
            myThread.Start()
        Next i

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

    End Sub 'Main

    Private Shared Sub MyThreadProc()
        Dim i As Integer
        For i = 1 To numIterations
            UseResource()
        Next i
    End Sub 'MyThreadProc

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Shared Sub UseResource()
        ' Wait until it is safe to enter.
        mut.WaitOne()

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

        ' Place code to access non-reentrant resources here.

        ' Simulate some work
        Thread.Sleep(500)

        Console.WriteLine("{0} is leaving protected area" & vbCrLf, _
            Thread.CurrentThread.Name)

        ' Release Mutex.
        mut.ReleaseMutex()
    End Sub 'UseResource
End Class 'MyMainClass

[C#] 
// 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();
    }
}

[C++] 
// 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 <mscorlib.dll>

using namespace System;
using namespace System::Threading;

const int numIterations = 1;
const int numThreads = 3;

__gc class Test
{
public:
    // Create a new Mutex. The creating thread does not own the
    // Mutex.
    static Mutex* mut = new Mutex();

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

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

        Console::WriteLine(S"{0} has entered protected the area", 
            Thread::CurrentThread->Name
            );

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

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

        Console::WriteLine(S"{0} is leaving protected the area\r\n",
            Thread::CurrentThread->Name
            );

        // Release the Mutex.
        mut->ReleaseMutex();
    }
};

int main() 
{
    // Create the threads that will use the protected resource.
    for (int i = 0; i < numThreads; i++) 
    {
        Thread * myThread = new Thread(
            new ThreadStart(0, Test::MyThreadProc)
            );
        myThread->Name = String::Format(S"Thread {0}", __box(i + 1));
        myThread->Start();
    }

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

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Namespace: System.Threading

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family, .NET Compact Framework

Assembly: Mscorlib (in Mscorlib.dll)

See Also

Mutex Members | System.Threading Namespace | WaitHandle | Thread | Threading | Mutex | Managed and Unmanaged Threading

Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft