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 метод , чтобы освободить владение мьютексом. Первый пример в разделе Примеры иллюстрирует этот шаблон.

• Истек интервал времени ожидания, указанный в вызове WaitOne метода с параметром millisecondsTimeout или timeout . В этом случае WaitOne метод возвращает false, а вызывающий поток не предпринимает дальнейших попыток получить владение мьютексом. В этом случае следует структурировать код таким образом, чтобы доступ к ресурсу, защищенному мьютексом, был запрещен вызывающему потоку. Так как поток никогда не приобретал права владения мьютексом, он не должен вызывать ReleaseMutex метод . Второй пример в разделе Примеры иллюстрирует этот шаблон.

Класс Mutex применяет удостоверение потока, поэтому мьютекс может быть освобожден только потоком, который его получил. В отличие от этого, Semaphore класс не применяет удостоверение потока. Мьютекс также может передаваться через границы домена приложения.

Поток, владеющий мьютексом, может запрашивать тот же мьютекс в повторяющихся вызовах , WaitOne не блокируя его выполнение. Однако поток должен вызывать ReleaseMutex метод одинаковое количество раз, чтобы освободить владение мьютексом.

Mutex Так как класс наследуется от WaitHandle, можно также вызвать статические WaitHandle.WaitAll методы и для WaitHandle.WaitAny синхронизации доступа к защищенному ресурсу.

Если поток завершается при владении мьютексом, мьютекс считается отмененным. Состояние мьютекса устанавливается в signaled, и следующий ожидая поток получает право собственности. Начиная с версии 2.0 платформа .NET Framework в следующем потоке возникает исключение AbandonedMutexException , которое получает заброшенный мьютекс. До версии 2.0 платформа .NET Framework исключение не было создано.

В случае системного мьютекса брошенный мьютекс может указывать на то, что работа приложения была внезапно прекращена (например, с помощью диспетчера задач Windows).

Мьютексы бывают двух типов: локальные мьютексы без имени и именованные системные мьютексы. Локальный мьютекс существует только в вашем процессе. Его может использовать любой поток в процессе, имеющий ссылку Mutex на объект, представляющий мьютекс. Каждый неименованный Mutex объект представляет отдельный локальный мьютекс.

Именованные системные мьютексы видны во всей операционной системе и могут использоваться для синхронизации действий процессов. Вы можете создать Mutex объект, представляющий именованный системный мьютекс, с помощью конструктора, принимающего имя. Объект операционной системы может быть создан одновременно или существовать до создания Mutex объекта . Вы можете создать сразу несколько объектов Mutex, представляющих один и тот именованный системный мьютекс, а также открывать именованный системный мьютекс с помощью метода OpenExisting.

Обратная косая черта (\) — это зарезервированный символ в имени мьютекса. Не используйте обратную косую черту (\) в имени мьютекса, за исключением случаев, указанных в примечании об использовании мьютексов в сеансах сервера терминалов. В противном случае может возникнуть исключение DirectoryNotFoundException, даже если имя мьютекса представляет существующий файл.

Конструкторы

Поля

Свойства

Методы

Явные реализации интерфейса

Методы расширения

Применяется к

Потокобезопасность

Данный тип потокобезопасен.

См. также раздел

• WaitHandle
• Thread
• Управляемая поточность
• Мьютексы