Mutex Klasa

Definicja

Przestrzeń nazw:
System.Threading
Zestawy:
mscorlib.dll, System.Threading.dll
Zestawy:
netstandard.dll, System.Threading.dll
Zestaw:
System.Threading.dll
Zestaw:
mscorlib.dll
Zestaw:
netstandard.dll
Źródło:
Mutex.cs
Źródło:
Mutex.cs
Źródło:
Mutex.cs
Źródło:
Mutex.cs
Źródło:
Mutex.cs

Pierwotny element synchronizacji, który może być również używany do synchronizacji międzyprocesowej.

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
Dziedziczenie
Object
WaitHandle
Mutex
Dziedziczenie
Object
MarshalByRefObject
WaitHandle
Mutex
Atrybuty
ComVisibleAttribute

Przykłady

W tym przykładzie pokazano, jak obiekt lokalny Mutex jest używany do synchronizowania dostępu do chronionego zasobu. Ponieważ każdy wątek wywołujący jest blokowany do momentu uzyskania własności mutexu, musi wywołać metodę ReleaseMutex , aby zwolnić własność mutexu.

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

W poniższym przykładzie każdy wątek wywołuje metodę WaitOne(Int32) w celu uzyskania mutexu. Jeśli interwał limitu czasu upłynie, metoda zwraca falsewartość , a wątek nie uzyskuje ani mutex, ani nie uzyskuje dostępu do zasobu chronionego przez mutex. Metoda ReleaseMutex jest wywoływana tylko przez wątek, który uzyskuje 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

Uwagi

Gdy co najmniej dwa wątki muszą jednocześnie uzyskać dostęp do zasobu udostępnionego, system potrzebuje mechanizmu synchronizacji, aby zapewnić, że tylko jeden wątek jednocześnie używa zasobu. Mutex jest elementem pierwotnym synchronizacji, który udziela wyłącznego dostępu do zasobu udostępnionego tylko do jednego wątku. Jeśli wątek uzyskuje mutex, drugi wątek, który chce uzyskać ten mutex jest zawieszony do momentu wydania pierwszego wątku mutex.

Ważna

Ten typ implementuje interfejs IDisposable. Po zakończeniu korzystania z typu danych, należy go usunąć w sposób bezpośredni lub pośredni. Aby usunąć typ bezpośrednio, wywołaj metodę Dispose w bloku try/catch. Aby usunąć go pośrednio, należy użyć konstrukcji języka, takiej jak using (w języku C#) lub Using (w Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Używanie obiektu implementującego IDisposable" (Using an Object that Implements IDisposable) w temacie interfejsu IDisposable.

Możesz użyć WaitHandle.WaitOne metody , aby zażądać własności mutexu. Wątek wywołujący blokuje się do momentu wystąpienia jednego z następujących elementów:

  • Mutex jest sygnalizowany, aby wskazać, że nie jest własnością. W takim przypadku WaitOne metoda zwraca metodę true, a wątek wywołujący przyjmuje własność mutexu i uzyskuje dostęp do zasobu chronionego przez mutex. Po zakończeniu uzyskiwania dostępu do zasobu wątek musi wywołać metodę ReleaseMutex , aby zwolnić własność mutexu. Pierwszy przykład w sekcji Przykłady ilustruje ten wzorzec.

  • Interwał limitu czasu określony w wywołaniu WaitOne metody, która ma millisecondsTimeout parametr or timeout , upłynął. W takim przypadku WaitOne metoda zwraca falsemetodę , a wątek wywołujący nie podejmuje dalszych prób uzyskania własności mutexu. W takim przypadku należy sstrukturę kodu, aby dostęp do zasobu chronionego przez mutex został odrzucony w wątku wywołującym. Ponieważ wątek nigdy nie nabył własności mutexu, nie może wywołać ReleaseMutex metody . Drugi przykład w sekcji Przykłady ilustruje ten wzorzec.

Klasa Mutex wymusza tożsamość wątku, więc mutex można zwolnić tylko przez wątek, który go nabył. Z kolei Semaphore klasa nie wymusza tożsamości wątku. Można również przekazać mutex przez granice domeny aplikacji.

Wątek, który jest właścicielem mutex, może zażądać tego samego mutexu w powtarzających się wywołaniach WaitOne bez blokowania jego wykonywania. Jednak wątek musi wywołać ReleaseMutex tę samą liczbę razy, aby zwolnić własność mutexu.

Mutex Ponieważ klasa dziedziczy z WaitHandleklasy , można również wywołać metody statyczne WaitHandle.WaitAll i WaitHandle.WaitAny w celu zsynchronizowania dostępu do chronionego zasobu.

Jeśli wątek kończy się podczas posiadania mutexu, mutex mówi się, że zostanie porzucony. Stan mutex jest ustawiony na sygnalizowany, a następny wątek oczekiwania dostaje własność. Począwszy od wersji 2.0 struktury .NET, w następnym wątku jest zgłaszany AbandonedMutexException, który uzyskuje porzucony mutex. Przed wersją 2.0 programu .NET Framework nie zgłoszono wyjątku.

Caution

Porzucony mutex często wskazuje poważny błąd w kodzie. Gdy wątek kończy się bez zwalniania mutexu, struktury danych chronione przez mutex mogą nie być w stanie spójnym. Następny wątek żądania własności mutex może obsłużyć ten wyjątek i kontynuować, jeśli można zweryfikować integralność struktur danych.

W przypadku mutexu całego systemu porzucony mutex może wskazywać, że aplikacja została nagle zakończona (na przykład przy użyciu Menedżera zadań systemu Windows).

Mutexes mają dwa typy: lokalne mutexy, które nie są nazwane i nazwane mutexes systemu. Lokalny mutex istnieje tylko w ramach twojego procesu. Może być używany przez dowolny wątek w procesie, który zawiera odwołanie do Mutex obiektu reprezentującego mutex. Każdy nienazwany Mutex obiekt reprezentuje oddzielny lokalny mutex.

Nazwane mutexy systemu są widoczne w całym systemie operacyjnym i mogą służyć do synchronizowania działań procesów. Można utworzyć Mutex obiekt reprezentujący nazwany mutex systemu przy użyciu konstruktora, który akceptuje nazwę. Obiekt systemu operacyjnego można utworzyć w tym samym czasie lub może istnieć przed utworzeniem Mutex obiektu. Można utworzyć wiele Mutex obiektów reprezentujących ten sam nazwany systemowy mutex i użyć metody OpenExisting do otwarcia istniejącego nazwanego mutexu systemowego.

Uwaga / Notatka

Na serwerze z uruchomionymi usługami terminali nazwany mutex systemu może mieć dwa poziomy widoczności. Jeśli nazwa zaczyna się od prefiksu Global\, mutex jest widoczny we wszystkich sesjach serwera terminali. Jeśli jego nazwa zaczyna się od prefiksu Local\, mutex jest widoczny tylko w sesji serwera terminali, w której został utworzony. W takim przypadku oddzielny mutex o tej samej nazwie może istnieć w każdej z pozostałych sesji serwera terminali na serwerze. Jeśli nie określisz prefiksu podczas tworzenia nazwanego mutexu, przyjmuje prefiks Local\. W ramach sesji serwera terminalu dwa elementy muteksów, których nazwy różnią się tylko ich prefiksami, są oddzielnymi mutekami, a oba są widoczne dla wszystkich procesów w sesji serwera terminalu. Oznacza to, że nazwy Global\ prefiksów i Local\ opisują zakres nazwy mutex względem sesji serwera terminali, a nie względem procesów.

Caution

Domyślnie nazwany mutex nie jest ograniczony do użytkownika, który go utworzył. Inni użytkownicy mogą być w stanie otworzyć i użyć mutexu, w tym zakłócać działanie mutexu, wprowadzając mutex i nie zamykając go. W systemach operacyjnych podobnych do unix system plików jest używany w implementacji nazwanych mutexes, a inni użytkownicy mogą zakłócać nazwane mutexes na bardziej znaczący sposób. W Windows, aby ograniczyć dostęp do określonych użytkowników, można użyć przeciążenia konstruktora lub MutexAcl i przekazać MutexSecurity podczas tworzenia nazwanego mutexu. W systemach operacyjnych przypominających system Unix obecnie nie ma możliwości ograniczenia dostępu do nazwanego mutexu. Unikaj używania nazwanych mutexes bez ograniczeń dostępu do systemów, które mogą mieć niezaufanych użytkowników z uruchomionym kodem.

Ukośnik odwrotny (\) jest znakiem zastrzeżonym w nazwie mutex. Nie należy używać ukośnika odwrotnego (\) w nazwie mutex z wyjątkiem określonych w notatce dotyczącej używania mutexes w sesjach serwera terminali. DirectoryNotFoundException W przeciwnym razie może zostać zgłoszony wyjątek, mimo że nazwa mutexu reprezentuje istniejący plik.

Konstruktory

Nazwa Opis
Mutex()

Inicjuje Mutex nowe wystąpienie klasy z właściwościami domyślnymi.
Mutex(Boolean, String, Boolean, MutexSecurity)

Inicjuje nowe wystąpienie Mutex klasy z wartością logiczną, która wskazuje, czy wątek wywołujący powinien mieć początkową własność mutex, ciąg, który jest nazwą mutex, zmienną logiczną, która, gdy metoda zwraca, wskazuje, czy wątek wywołujący otrzymał wstępną własność mutex, oraz zabezpieczenia kontroli dostępu, które mają zostać zastosowane do nazwanego mutexu.
Mutex(Boolean, String, Boolean)

Inicjuje nowe wystąpienie Mutex klasy z wartością logiczną wskazującą, czy wątek wywołujący powinien mieć początkową własność mutex, ciąg, który jest nazwą mutexu, oraz wartość logiczną, która, gdy metoda zwraca, wskazuje, czy wątek wywołujący otrzymał początkową własność mutexu.
Mutex(Boolean, String, NamedWaitHandleOptions, Boolean)

Inicjuje nowe wystąpienie klasy z wartością logiczną, która wskazuje, czy wątek Mutex wywołujący powinien mieć początkową własność mutex, ciąg, który jest nazwą mutexu, opcje ustawiania dostępu zakresu użytkownika i zakresu sesji oraz wartość logiczna, która, gdy metoda zwraca, wskazuje, czy wątek wywołujący otrzymał początkową własność mutexu.
Mutex(Boolean, String, NamedWaitHandleOptions)

Inicjuje nowe wystąpienie Mutex klasy z wartością logiczną wskazującą, czy wątek wywołujący powinien mieć początkową własność mutex, ciąg, który jest nazwą mutexu, oraz opcje ustawiania dostępu do zakresu użytkownika i zakresu sesji.
Mutex(Boolean, String)

Inicjuje nowe wystąpienie Mutex klasy z wartością logiczną wskazującą, czy wątek wywołujący powinien mieć początkową własność mutexu, oraz ciąg, który jest nazwą mutexu.
Mutex(Boolean)

Inicjuje nowe wystąpienie Mutex klasy z wartością logiczną wskazującą, czy wątek wywołujący powinien mieć początkową własność mutexu.
Mutex(String, NamedWaitHandleOptions)

Inicjuje nowe wystąpienie Mutex klasy z ciągiem, który jest nazwą mutex i opcji, aby ustawić dostęp do zakresu użytkownika i zakresu sesji. Wątek wywołujący nie żąda posiadania początkowej własności mutexu.

Pola

Nazwa Opis
WaitTimeout

Wskazuje, że WaitAny(WaitHandle[], Int32, Boolean) upłynął limit czasu operacji, zanim zostanie zasygnalizowana którakolwiek z dojść oczekiwania. To pole jest stałe.

(Odziedziczone po WaitHandle)

Właściwości

Nazwa Opis
Handle
Przestarzałe.
Przestarzałe.

Pobiera lub ustawia natywny uchwyt systemu operacyjnego.

(Odziedziczone po WaitHandle)
SafeWaitHandle

Pobiera lub ustawia natywny uchwyt systemu operacyjnego.

(Odziedziczone po WaitHandle)

Metody

Nazwa Opis
Close()

Zwalnia wszystkie zasoby przechowywane przez bieżący WaitHandleelement .

(Odziedziczone po WaitHandle)
CreateObjRef(Type)

Tworzy obiekt zawierający wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikowania się z obiektem zdalnym.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie WaitHandle klasy.

(Odziedziczone po WaitHandle)
Dispose(Boolean)

Po zastąpieniu w klasie pochodnej zwalnia niezarządzane zasoby używane przez WaitHandleprogram i opcjonalnie zwalnia zarządzane zasoby.

(Odziedziczone po WaitHandle)
Equals(Object)

Określa, czy określony obiekt jest równy bieżącemu obiektowi.

(Odziedziczone po Object)
GetAccessControl()

MutexSecurity Pobiera obiekt reprezentujący zabezpieczenia kontroli dostępu dla nazwanego mutexu.
GetHashCode()

Służy jako domyślna funkcja skrótu.

(Odziedziczone po Object)
GetLifetimeService()
Przestarzałe.

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
GetType()

Pobiera Type bieżącego wystąpienia.

(Odziedziczone po Object)
InitializeLifetimeService()
Przestarzałe.

Uzyskuje obiekt usługi okresu istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy płytkią kopię bieżącego Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy płytkią kopię bieżącego MarshalByRefObject obiektu.

(Odziedziczone po MarshalByRefObject)
OpenExisting(String, MutexRights)

Otwiera określony nazwany mutex, jeśli już istnieje, z żądanym dostępem zabezpieczeń.
OpenExisting(String, NamedWaitHandleOptions)

Otwiera określony nazwany mutex, jeśli już istnieje. Jeśli opcje są ustawione tylko dla bieżącego użytkownika, kontrole dostępu obiektu są weryfikowane dla użytkownika wywołującego.
OpenExisting(String)

Otwiera określony nazwany mutex, jeśli już istnieje.
ReleaseMutex()

Zwalnia raz Mutex .
SetAccessControl(MutexSecurity)

Ustawia zabezpieczenia kontroli dostępu dla nazwanego mutexu systemowego.
ToString()

Zwraca ciąg reprezentujący bieżący obiekt.

(Odziedziczone po Object)
TryOpenExisting(String, Mutex)

Otwiera określony nazwany mutex, jeśli już istnieje i zwraca wartość wskazującą, czy operacja zakończyła się pomyślnie.
TryOpenExisting(String, MutexRights, Mutex)

Otwiera określony nazwany mutex, jeśli już istnieje, z żądanym dostępem zabezpieczeń i zwraca wartość wskazującą, czy operacja zakończyła się pomyślnie.
TryOpenExisting(String, NamedWaitHandleOptions, Mutex)

Otwiera określony nazwany mutex, jeśli już istnieje i zwraca wartość wskazującą, czy operacja zakończyła się pomyślnie. Jeśli opcje są ustawione tylko dla bieżącego użytkownika, kontrole dostępu obiektu są weryfikowane dla użytkownika wywołującego.
WaitOne()

Blokuje bieżący wątek, dopóki bieżący nie WaitHandle otrzyma sygnału.

(Odziedziczone po WaitHandle)
WaitOne(Int32, Boolean)

Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej liczby całkowitej ze znakiem, aby określić interwał czasu i określić, czy zakończyć domenę synchronizacji przed oczekiwaniem.

(Odziedziczone po WaitHandle)
WaitOne(Int32)

Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej liczby całkowitej ze znakiem w celu określenia interwału czasu w milisekundach.

(Odziedziczone po WaitHandle)
WaitOne(TimeSpan, Boolean)

Blokuje bieżący wątek, dopóki bieżące wystąpienie nie odbierze sygnału, używając parametru , TimeSpan aby określić interwał czasu i określić, czy należy zamknąć domenę synchronizacji przed oczekiwaniem.

(Odziedziczone po WaitHandle)
WaitOne(TimeSpan)

Blokuje bieżący wątek do momentu odebrania sygnału przez bieżące wystąpienie przy użyciu parametru , TimeSpan aby określić interwał czasu.

(Odziedziczone po WaitHandle)

Jawne implementacje interfejsu

Nazwa Opis
IDisposable.Dispose()

Ten interfejs API obsługuje infrastrukturę produktu i nie jest przeznaczony do użycia bezpośrednio z poziomu kodu.

Zwalnia wszystkie zasoby używane przez program WaitHandle.

(Odziedziczone po WaitHandle)

Metody rozszerzania

Nazwa Opis
GetAccessControl(Mutex)

Zwraca deskryptory zabezpieczeń dla określonego mutexelementu .
GetSafeWaitHandle(WaitHandle)

Pobiera bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.
SetAccessControl(Mutex, MutexSecurity)

Ustawia deskryptory zabezpieczeń dla określonego mutexu.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Ustawia bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkiem.

Zobacz też