Mutex Класс

Определение

Примитив синхронизации, который также может использоваться в межпроцессорной синхронизации.A synchronization primitive that can also be used for interprocess synchronization.

public ref class Mutex sealed : System::Threading::WaitHandle
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.WaitHandle
type Mutex = class
    inherit WaitHandle
Public NotInheritable Class Mutex
Inherits WaitHandle
Наследование
Атрибуты

Примеры

В этом примере показано, как Mutex локальный объект используется для синхронизации доступа к защищенному ресурсу.This example shows how a local Mutex object is used to synchronize access to a protected resource. Поскольку каждый вызывающий поток блокируется до тех пор, пока не получит владение мьютексом, ReleaseMutex он должен вызвать метод, чтобы освободить владение потоком.Because each calling thread is blocked until it acquires ownership of the mutex, it must call the ReleaseMutex method to release ownership of the thread.

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) метод для получения мьютекса.In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. Если интервал времени ожидания истекает, метод возвращает false, а поток не получает мьютекс и не получает доступ к ресурсу, который защищает мьютекс.If the time-out interval elapses, the method returns false, and the thread neither acquires the mutex nor gains access to the resource the mutex protects. ReleaseMutex Метод вызывается только потоком, который получает мьютекс.The ReleaseMutex method is called only by the thread that acquires the mutex.

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

Комментарии

Когда двум или более потокам требуется одновременный доступ к общему ресурсу, системе необходим механизм синхронизации, гарантирующий, что ресурс будет использоваться только одним потоком в каждый момент времени.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— это примитив синхронизации, предоставляющий эксклюзивный доступ к общему ресурсу только одному потоку.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.

Важно!

Этот тип реализует интерфейс IDisposable.This type implements the IDisposable interface. По окончании использования выдаленную ему память следует прямо или косвенно освободить.When you have finished using the type, you should dispose of it either directly or indirectly. Чтобы сделать это прямо, вызовите его метод Dispose в блоке try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Чтобы сделать это косвенно, используйте языковые конструкции, такие как using (в C#) или Using (в Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Дополнительные сведения см. в разделе "Использование объекта, реализующего IDisposable" в статье об интерфейсе IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

WaitHandle.WaitOne Метод можно использовать для запроса владения мьютексом.You can use the WaitHandle.WaitOne method to request ownership of a mutex. Вызывающий поток блокируется до тех пор, пока не произойдет одно из следующих событий:The calling thread blocks until one of the following occurs:

  • Мьютекс получает сигнал, указывающий, что он не принадлежит.The mutex is signaled to indicate that it is not owned. В WaitOne этом случае метод возвращает trueзначение, и вызывающий поток принимает владение мьютексом и обращается к ресурсу, защищенному мьютексом.When this happens, the WaitOne method returns true, and the calling thread assumes ownership of the mutex and accesses the resource protected by the mutex. После завершения доступа к ресурсу поток должен вызвать ReleaseMutex метод, чтобы освободить владение мьютексом.When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. В первом примере в разделе "примеры" показан этот шаблон.The first example in the Examples section illustrates this pattern.

  • Истекает интервал времени ожидания, указанный в вызове WaitOne метода с millisecondsTimeout параметром или timeout .The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. В этом случае метод возвращает WaitOne falseзначение, и вызывающий поток не предпринимает дальнейших попыток получить владение мьютексом.When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. В этом случае необходимо структурировать код таким образом, чтобы доступ к ресурсу, защищенному мьютексом, был запрещен вызывающему потоку.In this case, you should structure your code so that access to the resource that is protected by the mutex is denied to the calling thread. Поскольку поток никогда не получил владение мьютексом, он не должен вызывать ReleaseMutex метод.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. Второй пример в разделе "примеры" иллюстрирует этот шаблон.The second example in the Examples section illustrates this pattern.

Mutex Класс применяет удостоверение потока, поэтому мьютекс может быть освобожден только потоком, который его получил.The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. В Semaphore отличие от этого, класс не применяет удостоверение потока.By contrast, the Semaphore class does not enforce thread identity. Мьютекс также может передаваться через границы домена приложения.A mutex can also be passed across application domain boundaries.

Поток, владеющий мьютексом, может запрашивать один и тот же мьютекс WaitOne в повторяющихся вызовах без блокирования его выполнения.The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. Однако поток должен вызвать ReleaseMutex метод таким же количество раз, чтобы освободить владение мьютексом.However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

Поскольку класс наследуется от WaitHandle, можно также вызвать статические WaitHandle.WaitAll методы и WaitHandle.WaitAny для синхронизации доступа к защищенному ресурсу. MutexBecause the Mutex class inherits from WaitHandle, you can also call the static WaitHandle.WaitAll and WaitHandle.WaitAny methods to synchronize access to a protected resource.

Если поток завершается во время владения мьютексом, мьютекс считается брошенным.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. Начиная с версии 2,0 .NET Framework, AbandonedMutexException в следующем потоке, который получает брошенный мьютекс, создается исключение.Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. До версии 2,0 .NET Framework не было создано исключение.Before version 2.0 of the .NET Framework, no exception was thrown.

Внимание!

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

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

Мьютексы бывают двух типов: локальные мьютексы, которые являются неименованными, и именованные системные мьютексы.Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. Локальный мьютекс существует только в вашем процессе.A local mutex exists only within your process. Он может использоваться любым потоком в процессе, имеющим ссылку на Mutex объект, представляющий мьютекс.It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Каждый неименованный Mutex объект представляет отдельный локальный мьютекс.Each unnamed Mutex object represents a separate local mutex.

Именованные системные мьютексы видимы во всей операционной системе и могут использоваться для синхронизации действий процессов.Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. Можно создать Mutex объект, представляющий именованный системный мьютекс, с помощью конструктора, принимающего имя.You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. Объект операционной системы может быть создан одновременно, или же он может существовать до создания Mutex объекта.The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. Вы можете создать сразу несколько объектов Mutex, представляющих один и тот именованный системный мьютекс, а также открывать именованный системный мьютекс с помощью метода OpenExisting.You can create multiple Mutex objects that represent the same named system mutex, and you can use the OpenExisting method to open an existing named system mutex.

Примечание

На сервере, на котором выполняются службы терминалов, именованный системный мьютекс может иметь два уровня видимости.On a server that is running Terminal Services, a named system mutex can have two levels of visibility. Если его имя начинается с префикса "Global\", мьютекс является видимым во всех сеансах сервера терминалов.If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. Если его имя начинается с префикса Local\, мьютекс является видимым только в сеансе сервера терминалов, где он был создан.If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. В этом случае отдельный мьютекс с одним и тем же именем может существовать в каждом сеансе сервера терминалов на сервере.In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. Если префикс не указан при создании именованного мьютекса, он принимает префикс Local\.If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". В сеансе сервера терминалов два мьютекса, имена которых отличаются только префиксами, являются отдельными мьютексами, и оба они видимы для всех процессов в сеансе сервера терминалов.Within a terminal server session, two mutexes whose names differ only by their prefixes are separate mutexes, and both are visible to all processes in the terminal server session. То есть префикс именуется "Global\" и "Local\", описывающий область действия имени мьютекса относительно сеансов сервера терминалов, а не относительно процессов.That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

Обратная косая черта (\) является зарезервированным знаком в имени мьютекса.The backslash (\) is a reserved character in a mutex name. Используйте обратную косую черту (\) в имени мьютекса только в соответствии с примечанием об использовании мьютексов в сеансах сервера терминалов.Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. В противном случае может возникнуть исключение DirectoryNotFoundException, даже если имя мьютекса представляет существующий файл.Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

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

Mutex()

Инициализирует новый экземпляр класса Mutex стандартными свойствами.Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean)

Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, является ли вызывающий поток изначальным владельцем мьютекса.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex.

Mutex(Boolean, String)

Инициализирует новый экземпляр класса Mutex с логическим значением, показывающим необходимость наличия начального владения семафором у вызывающего потока, и строкой, являющейся именем семафора.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, and a string that is the name of the mutex.

Mutex(Boolean, String, Boolean)

Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, иметь строку, являющуюся именем мьютекса, и логическое значение, которое при возврате метода показывает, предоставлено ли вызывающему потоку изначальное владение мьютексом.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, and a Boolean value that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex.

Mutex(Boolean, String, Boolean, MutexSecurity)

Инициализирует новый экземпляр класса Mutex логическим значением, указывающим, должен ли вызывающий поток быть изначальным владельцем мьютекса, иметь строку, являющуюся именем мьютекса, и логическое значение, которое при возврате метода показывает, предоставлено ли вызывающему потоку изначальное владение мьютексом, а также безопасность управления доступом для применения к именованному мьютексу.Initializes a new instance of the Mutex class with a Boolean value that indicates whether the calling thread should have initial ownership of the mutex, a string that is the name of the mutex, a Boolean variable that, when the method returns, indicates whether the calling thread was granted initial ownership of the mutex, and the access control security to be applied to the named mutex.

Поля

WaitTimeout

Указывает, что время ожидания операции WaitAny(WaitHandle[], Int32, Boolean) истекло до получения сигнала каким-либо из дескрипторов ожидания.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Это поле является константой.This field is constant.

(Унаследовано от WaitHandle)

Свойства

Handle

Возвращает или задает собственный дескриптор операционной системы.Gets or sets the native operating system handle.

(Унаследовано от WaitHandle)
SafeWaitHandle

Возвращает или задает собственный дескриптор операционной системы.Gets or sets the native operating system handle.

(Унаследовано от WaitHandle)

Методы

Close()

Освобождает все ресурсы, удерживаемые текущим объектом WaitHandle.Releases all resources held by the current WaitHandle.

(Унаследовано от WaitHandle)
CreateObjRef(Type)

Создает объект, который содержит всю необходимую информацию для создания прокси-сервера, используемого для взаимодействия с удаленным объектом.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Унаследовано от MarshalByRefObject)
Dispose()

Освобождает все ресурсы, используемые текущим экземпляром класса WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Унаследовано от WaitHandle)
Dispose(Boolean)

При переопределении в производном классе освобождает неуправляемые ресурсы, используемые объектом WaitHandle, и при необходимости освобождает управляемые ресурсы.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Унаследовано от WaitHandle)
Equals(Object)

Определяет, равен ли указанный объект текущему объекту.Determines whether the specified object is equal to the current object.

(Унаследовано от Object)
GetAccessControl()

Получает объект MutexSecurity, представляющий безопасность управления доступом для именованного мьютекса.Gets a MutexSecurity object that represents the access control security for the named mutex.

GetHashCode()

Служит в качестве хэш-функции по умолчанию.Serves as the default hash function.

(Унаследовано от Object)
GetLifetimeService()

Извлекает объект обслуживания во время существования, который управляет политикой времени существования данного экземпляра.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Унаследовано от MarshalByRefObject)
GetType()

Возвращает объект Type для текущего экземпляра.Gets the Type of the current instance.

(Унаследовано от Object)
InitializeLifetimeService()

Получает объект службы времени существования для управления политикой времени существования для этого экземпляра.Obtains a lifetime service object to control the lifetime policy for this instance.

(Унаследовано от MarshalByRefObject)
MemberwiseClone()

Создает неполную копию текущего объекта Object.Creates a shallow copy of the current Object.

(Унаследовано от Object)
MemberwiseClone(Boolean)

Создает неполную копию текущего объекта MarshalByRefObject.Creates a shallow copy of the current MarshalByRefObject object.

(Унаследовано от MarshalByRefObject)
OpenExisting(String)

Открывает указанный именованный мьютекс, если он уже существует.Opens the specified named mutex, if it already exists.

OpenExisting(String, MutexRights)

Открывает указанный именованный мьютекс, если он уже существует, с требуемыми правами доступа.Opens the specified named mutex, if it already exists, with the desired security access.

ReleaseMutex()

Освобождает объект Mutex один раз.Releases the Mutex once.

SetAccessControl(MutexSecurity)

Задает безопасность управления доступом для именованного системного мьютекса.Sets the access control security for a named system mutex.

ToString()

Возвращает строку, представляющую текущий объект.Returns a string that represents the current object.

(Унаследовано от Object)
TryOpenExisting(String, Mutex)

Открывает указанный именованный мьютекс, если он уже существует, и возвращает значение, указывающее, успешно ли выполнена операция.Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, MutexRights, Mutex)

Открывает указанный именованный мьютекс, если он уже существует, с требуемыми правами доступа, и возвращает значение, указывающее, успешно ли выполнена операция.Opens the specified named mutex, if it already exists, with the desired security access, and returns a value that indicates whether the operation succeeded.

WaitOne()

Блокирует текущий поток до получения сигнала объектом WaitHandle.Blocks the current thread until the current WaitHandle receives a signal.

(Унаследовано от WaitHandle)
WaitOne(Int32)

Блокирует текущий поток до получения текущим дескриптором WaitHandle сигнала, используя 32-разрядное целое число со знаком для указания интервала времени в миллисекундах.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Унаследовано от WaitHandle)
WaitOne(Int32, Boolean)

Блокирует текущий поток до получения сигнала текущим объектом WaitHandle, используя 32-разрядное целое число со знаком для задания периода времени и указывая, следует ли выйти из домена синхронизации до начала ожидания.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Унаследовано от WaitHandle)
WaitOne(TimeSpan)

Блокирует текущий поток до получения сигнала текущим экземпляром, используя значение типа TimeSpan для указания интервала времени.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Унаследовано от WaitHandle)
WaitOne(TimeSpan, Boolean)

Блокирует текущий поток до получения сигнала текущим экземпляром, используя значение типа TimeSpan для задания интервала времени и указывая, следует ли выйти из домена синхронизации до начала ожидания.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval and specifying whether to exit the synchronization domain before the wait.

(Унаследовано от WaitHandle)

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

IDisposable.Dispose()

Освобождает все ресурсы, занятые модулем WaitHandle.Releases all resources used by the WaitHandle.

(Унаследовано от WaitHandle)

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

GetAccessControl(Mutex)
SetAccessControl(Mutex, MutexSecurity)
GetSafeWaitHandle(WaitHandle)

Возвращает безопасный дескриптор для собственного дескриптора ожидания операционной системы.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Задает безопасный дескриптор для собственного дескриптора ожидания операционной системы.Sets a safe handle for a native operating system wait handle.

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

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

Данный тип потокобезопасен.This type is thread safe.

Дополнительно