Mutex 类
一个同步基元，也可用于进程间同步。
**命名空间:**System.Threading
**程序集:**mscorlib（在 mscorlib.dll 中）
语法
声明
<ComVisibleAttribute(True)> _
Public NotInheritable Class Mutex
Inherits WaitHandle
用法
Dim instance As Mutex
[ComVisibleAttribute(true)]
public sealed class Mutex : WaitHandle
[ComVisibleAttribute(true)]
public ref class Mutex sealed : public WaitHandle
/** @attribute ComVisibleAttribute(true) */
public final class Mutex extends WaitHandle
ComVisibleAttribute(true)
public final class Mutex extends WaitHandle
备注
提示
应用于此类的 HostProtectionAttribute 属性 (Attribute) 具有下面的 Resources 属性 (Property) 值：Synchronization | ExternalThreading。HostProtectionAttribute 不影响桌面应用程序（桌面应用程序一般通过双击图标，键入命令或在浏览器中输入 URL 启动）。有关更多信息，请参见 HostProtectionAttribute 类或 SQL Server 编程和宿主保护属性。
当两个或更多线程需要同时访问一个共享资源时，系统需要使用同步机制来确保一次只有一个线程使用该资源。Mutex 是同步基元，它只向一个线程授予对共享资源的独占访问权。如果一个线程获取了互斥体，则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。
可以使用 WaitHandle.WaitOne 方法请求互斥体的所属权。拥有互斥体的线程可以在对 WaitOne 的重复调用中请求相同的互斥体而不会阻止其执行。但线程必须调用 ReleaseMutex 方法同样多的次数以释放互斥体的所属权。Mutex 类强制线程标识，因此互斥体只能由获得它的线程释放。相反，Semaphore 类不强制线程标识。
如果线程在拥有互斥体时终止，则称此互斥体被放弃。此互斥体被设置为终止状态，下一个等待的线程获得所属权。如果没有线程拥有互斥体，则互斥体状态为终止。从 .NET Framework 2.0 版开始，需要该互斥体的下一个线程将引发 AbandonedMutexException。在 .NET Framework 2.0 版之前，这样不会引发任何异常。
警告
出现遗弃的 Mutex 表明存在严重的编码错误。如果某个线程在未释放互斥体时便退出，受此互斥体保护的数据结构可能处于不一致的状态。如果此数据结构的完整性能得到验证，下一个请求此互斥体所属权的线程就可以处理此异常并继续。
互斥体有两种类型：局部互斥体和已命名的系统互斥体。如果使用接受名称的构造函数创建 Mutex 对象，则该对象与具有该名称的操作系统对象关联。已命名的系统互斥体在整个操作系统中都可见，可用于同步进程活动。您可以创建多个 Mutex 对象来表示同一个已命名的系统互斥体，也可以使用 OpenExisting 方法打开现有的已命名系统互斥体。
局部互斥体仅存在于您的进程内。您的进程中任何引用局部 Mutex 对象的线程都可以使用它。每个 Mutex 对象都是一个单独的局部互斥体。
示例
' 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
<MTAThread> _
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
// 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();
}
}
// 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 namespace System;
using namespace System::Threading;
const int numIterations = 1;
const int numThreads = 3;
ref class Test
{
public:
// Create a new Mutex. The creating thread does not own the
// Mutex.
static Mutex^ mut = gcnew 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( "{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( "{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 = gcnew Thread( gcnew ThreadStart( Test::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.
}
// 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.
import System.*;
import System.Threading.*;
import System.Threading.Thread;
class Test
{
// Create a new Mutex. The creating thread does not own the
// Mutex.
private static Mutex mut = new Mutex();
private static int numIterations = 1;
private static int numThreads = 3;
public static void main(String[] args)
{
// Create the threads that will use the protected resource.
for (int i = 0; i < numThreads; i++) {
Thread myThread = new Thread(new ThreadStart(MyThreadProc));
myThread.set_Name(String.Format("Thread{0}",
String.valueOf(i + 1)));
myThread.Start();
}
} //main
// 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();
}
} //MyThreadProc
// 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.get_CurrentThread().get_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.get_CurrentThread().get_Name());
// Release the Mutex.
mut.ReleaseMutex();
} //UseResource
} //Test
继承层次结构
System.Object
System.MarshalByRefObject
System.Threading.WaitHandle
System.Threading.Mutex
线程安全
该类型对于多线程操作是安全的。
平台
Windows 98、Windows 2000 SP4、Windows CE、Windows Millennium Edition、Windows Mobile for Pocket PC、Windows Mobile for Smartphone、Windows Server 2003、Windows XP Media Center Edition、Windows XP Professional x64 Edition、Windows XP SP2、Windows XP Starter Edition
.NET Framework 并不是对每个平台的所有版本都提供支持。有关受支持版本的列表，请参见系统要求。
版本信息
.NET Framework
受以下版本支持：2.0、1.1、1.0
.NET Compact Framework
受以下版本支持：2.0、1.0
请参见
参考
Mutex 成员
System.Threading 命名空间
WaitHandle
Thread