Mutex 类

定义

public ref class Mutex sealed : System::Threading::WaitHandle

public sealed class Mutex : System.Threading.WaitHandle

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.WaitHandle

type Mutex = class
    inherit WaitHandle

[<System.Runtime.InteropServices.ComVisible(true)>]
type Mutex = class
    inherit WaitHandle

Public NotInheritable Class Mutex
Inherits WaitHandle

继承

Object

WaitHandle

Mutex

继承

Object

MarshalByRefObject

WaitHandle

Mutex

属性

ComVisibleAttribute

示例

此示例演示如何使用本地 Mutex 对象来同步对受保护资源的访问。 由于每个调用线程在获取互斥体的所有权之前都会被阻止，因此它必须调用 ReleaseMutex 方法来释放互斥体的所有权。

using System;
using System.Threading;

class Example
{
    // 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 newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

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

    private static void ThreadProc()
    {
        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.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name);
        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", 
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name);
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread2 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread3 is requesting the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
//       Thread3 has released the mutex
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       Thread2 has released the mutex

Imports System.Threading

Module Example
   ' Create a new Mutex. The creating thread does not own the mutex.
   Private mut As New Mutex()
   Private Const numIterations As Integer = 1
   Private Const numThreads As Integer = 3
   
   Public Sub Main()
        ' Create the threads that will use the protected resource.
        For i As Integer = 0 To numThreads - 1
            Dim newThread As New Thread(AddressOf ThreadProc)
            newThread.Name = String.Format("Thread{0}", i + 1)
            newThread.Start()
        Next

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

    Private Sub ThreadProc()
        For i As Integer = 0 To numIterations - 1
            UseResource()
        Next
    End Sub

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Sub UseResource()
        ' Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name)
        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", 
            Thread.CurrentThread.Name)

        ' Release the Mutex.
        mut.ReleaseMutex()
        Console.WriteLine("{0} has released the mutex", 
            Thread.CurrentThread.Name)
   End Sub
End Module
' The example displays output like the following:
'       Thread1 is requesting the mutex
'       Thread2 is requesting the mutex
'       Thread1 has entered the protected area
'       Thread3 is requesting the mutex
'       Thread1 is leaving the protected area
'       Thread1 has released the mutex
'       Thread3 has entered the protected area
'       Thread3 is leaving the protected area
'       Thread3 has released the mutex
'       Thread2 has entered the protected area
'       Thread2 is leaving the protected area
'       Thread2 has released the mutex

在以下示例中，每个线程调用 WaitOne(Int32) 方法来获取互斥体。 如果超时间隔已过，该方法将返回 false，并且线程既不会获取互斥体，也不会获取对互斥体保护的资源的访问权限。 方法 ReleaseMutex 仅由获取互斥体的线程调用。

using System;
using System.Threading;

class Example
{
    // 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()
    {
        Example ex = new Example();
        ex.StartThreads();
    }

     private void StartThreads()
     {
        // Create the threads that will use the protected resource.
        for(int i = 0; i < numThreads; i++)
        {
            Thread newThread = new Thread(new ThreadStart(ThreadProc));
            newThread.Name = String.Format("Thread{0}", i + 1);
            newThread.Start();
        }

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

    private static void ThreadProc()
    {
        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, and do not enter if the request times out.
        Console.WriteLine("{0} is requesting the mutex", Thread.CurrentThread.Name);
        if (mut.WaitOne(1000)) {
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name);
   
           // Place code to access non-reentrant resources here.
   
           // Simulate some work.
           Thread.Sleep(5000);
   
           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name);
   
           // Release the Mutex.
              mut.ReleaseMutex();
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name);
        }
        else {
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name);
        }
    }

    ~Example()
    {
       mut.Dispose();
    }
}
// The example displays output like the following:
//       Thread1 is requesting the mutex
//       Thread1 has entered the protected area
//       Thread2 is requesting the mutex
//       Thread3 is requesting the mutex
//       Thread2 will not acquire the mutex
//       Thread3 will not acquire the mutex
//       Thread1 is leaving the protected area
//       Thread1 has released the mutex

Imports System.Threading

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

   Public Shared Sub Main()
      Dim ex As New Example()
      ex.StartThreads()
   End Sub
   
   Private Sub StartThreads()
        ' Create the threads that will use the protected resource.
        For i As Integer = 0 To numThreads - 1
            Dim newThread As New Thread(AddressOf ThreadProc)
            newThread.Name = String.Format("Thread{0}", i + 1)
            newThread.Start()
        Next

        ' The main thread returns to Main and exits, but the application continues to
        ' run until all foreground threads have exited.
   End Sub

   Private Sub ThreadProc()
        For i As Integer = 0 To numIterations - 1
            UseResource()
        Next
   End Sub

   ' This method represents a resource that must be synchronized
   ' so that only one thread at a time can enter.
   Private Sub UseResource()
        ' Wait until it is safe to enter.
        Console.WriteLine("{0} is requesting the mutex", 
                          Thread.CurrentThread.Name)
        If mut.WaitOne(1000) Then
           Console.WriteLine("{0} has entered the protected area", 
               Thread.CurrentThread.Name)
   
           ' Place code to access non-reentrant resources here.
   
           ' Simulate some work.
           Thread.Sleep(5000)
   
           Console.WriteLine("{0} is leaving the protected area", 
               Thread.CurrentThread.Name)
   
           ' Release the Mutex.
           mut.ReleaseMutex()
           Console.WriteLine("{0} has released the mutex", 
                             Thread.CurrentThread.Name)
        Else
           Console.WriteLine("{0} will not acquire the mutex", 
                             Thread.CurrentThread.Name)
        End If
   End Sub
   
   Protected Overrides Sub Finalize()
      mut.Dispose()
   End Sub
End Class
' The example displays output like the following:
'       Thread1 is requesting the mutex
'       Thread1 has entered the protected area
'       Thread2 is requesting the mutex
'       Thread3 is requesting the mutex
'       Thread2 will not acquire the mutex
'       Thread3 will not acquire the mutex
'       Thread1 is leaving the protected area
'       Thread1 has released the mutex

注解

当两个或多个线程需要同时访问共享资源时，系统需要同步机制来确保一次只有一个线程使用该资源。 Mutex 是一个同步基元，它仅向一个线程授予对共享资源的独占访问权限。 如果线程获取互斥体，则要获取该互斥的第二个线程将暂停，直到第一个线程释放互斥体。

可以使用 WaitHandle.WaitOne 方法请求互斥锁的所有权。 调用线程会阻塞，直到发生以下情况之一：

• 互斥体被发出信号，指示它不是拥有的。 发生这种情况时， WaitOne 方法返回 true，调用线程将假定互斥锁的所有权，并访问受互斥体保护的资源。 访问完资源后，线程必须调用 ReleaseMutex 方法来释放互斥体的所有权。 示例部分中的第一个示例演示了此模式。

• 调用具有 millisecondsTimeout 或 timeout 参数的方法中指定的WaitOne超时间隔已过。 发生这种情况时， WaitOne 方法返回 false，调用线程不会进一步尝试获取互斥体的所有权。 在这种情况下，应构建代码，以便拒绝对调用线程访问受互斥体保护的资源。 由于线程从未获取互斥体的所有权，因此它不得调用 ReleaseMutex 方法。 示例部分中的第二个示例演示了此模式。

类 Mutex 强制实施线程标识，因此只能由获取它的线程释放互斥体。 相比之下， Semaphore 类不强制实施线程标识。 互斥体也可以跨应用程序域边界传递。

拥有互斥体的线程可以在重复调用 WaitOne 中请求相同的互斥，而不会阻止其执行。 但是，线程必须调用 ReleaseMutex 方法的次数相同，才能释放互斥体的所有权。

Mutex由于 类继承自 WaitHandle，因此还可以调用静态 WaitHandle.WaitAll 和 WaitHandle.WaitAny 方法来同步对受保护资源的访问。

如果线程在拥有互斥体时终止，则表示该互斥体将被放弃。 互斥体的状态设置为已发出信号，下一个等待线程获取所有权。 从 .NET Framework 2.0 版开始，在下一个AbandonedMutexException获取已放弃的互斥体的线程中会引发 。 在 2.0 版.NET Framework之前，未引发异常。

对于系统范围的 mutex，放弃的 mutex 可能指示应用程序已突然终止（例如，通过使用 Windows 任务管理器终止）。

互斥体有两种类型：未命名的本地互斥体和命名系统互斥体。 本地 mutex 仅存在于进程中。 它可由进程中的任何线程使用，这些线程引用了 Mutex 表示互斥体的 对象。 每个未命名 Mutex 的对象都表示一个单独的本地互斥体。

命名的系统互斥体在整个操作系统中可见，可用于同步进程的活动。 可以使用接受名称的构造函数创建 Mutex 表示命名系统互斥体的对象。 操作系统对象可以同时创建，也可以在创建 Mutex 对象之前存在。 可以创建多个表示同一命名系统 mutex 的 Mutex 对象，还能使用 OpenExisting 方法打开现有的命名系统 mutex。

反斜杠 (\) 是互斥体名称中的保留字符。 请勿在互斥名称中使用反斜杠 (\) ，除非在终端服务器会话中使用互斥体的说明中所述。 否则，即使互斥体的名称表示现有文件，也可能引发 DirectoryNotFoundException。

构造函数

字段

属性

方法

显式接口实现

扩展方法

适用于

线程安全性

此类型是线程安全的。

另请参阅

• WaitHandle
• Thread
• 托管线程
• Mutex