This documentation is archived and is not being maintained.

Mutex.ReleaseMutex Method

Releases the Mutex once.

Namespace:  System.Threading
Assembly:  mscorlib (in mscorlib.dll)

public void ReleaseMutex()


The calling thread does not own the mutex.

A thread that owns a mutex can specify the same mutex in repeated wait function calls without blocking its execution. The number of calls is kept by the common language runtime. The thread must call ReleaseMutex the same number of times to release ownership of the mutex.

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. If no one owns the mutex, the state of the mutex is signaled. Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the mutex. Prior to version 2.0 of the .NET Framework, no exception was thrown.

Caution noteCaution

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).

The following 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. The ReleaseMutex method is used to release the mutex when it is no longer needed.

// 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);

        // 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++)

    // 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} has entered the protected area", 

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

        // Simulate some work.

        Console.WriteLine("{0} is leaving the protected area\r\n", 

        // Release the Mutex.

.NET Framework

Supported in: 4, 3.5, 3.0, 2.0, 1.1, 1.0

.NET Framework Client Profile

Supported in: 4, 3.5 SP1

Windows 7, Windows Vista SP1 or later, Windows XP SP3, Windows XP SP2 x64 Edition, Windows Server 2008 (Server Core not supported), Windows Server 2008 R2 (Server Core supported with SP1 or later), Windows Server 2003 SP2

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see .NET Framework System Requirements.