Mutex Klasa

Definicja

Element podstawowy synchronizacji, który może być również używany na potrzeby synchronizacji międzyprocesowej.A synchronization primitive that can also be used for interprocess synchronization.

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
Dziedziczenie
Atrybuty

Przykłady

Ten przykład pokazuje, jak Mutex obiekt lokalny jest używany do synchronizowania dostępu do chronionego zasobu.This example shows how a local Mutex object is used to synchronize access to a protected resource. Ponieważ każdy wywoływany wątek jest blokowany do momentu uzyskania własności obiektu mutex, musi wywołać metodę, ReleaseMutex Aby zwolnić własność obiektu mutex.Because each calling thread is blocked until it acquires ownership of the mutex, it must call the ReleaseMutex method to release ownership of 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()
    {
        // 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 WaitOne(Int32) metodę w celu uzyskania obiektu mutex.In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. Jeśli upłynie limit czasu, metoda zwróci wartość false , a wątek nie uzyska obiektu mutex ani nie uzyska dostępu do zasobu, którego zabezpiecza.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. ReleaseMutexMetoda jest wywoływana tylko przez wątek, który uzyskuje mutex.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

Uwagi

Gdy co najmniej dwa wątki muszą uzyskać dostęp do udostępnionego zasobu w tym samym czasie, system wymaga mechanizmu synchronizacji, aby upewnić się, że tylko jeden wątek w danym momencie używa zasobu.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 jest pierwotną synchronizacją, która przyznaje wyłączny dostęp do zasobu udostępnionego tylko jednemu wątkowi.Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. Jeśli wątek uzyskuje mutex, drugi wątek, który chce uzyskać ten mutex, jest zawieszony do momentu, gdy pierwszy wątek zwolni element mutex.If a thread acquires a mutex, the second thread that wants to acquire that mutex is suspended until the first thread releases the mutex.

Ważne

Ten typ implementuje IDisposable interfejs.This type implements the IDisposable interface. Po zakończeniu korzystania z typu należy usunąć jego wartość bezpośrednio lub pośrednio.When you have finished using the type, you should dispose of it either directly or indirectly. Aby usunąć typ bezpośrednio, wywołaj jego Dispose metodę w try / catch bloku.To dispose of the type directly, call its Dispose method in a try/catch block. Aby usunąć go pośrednio, użyj konstrukcji języka, takiej jak using (w języku C#) lub Using (w Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Aby uzyskać więcej informacji, zobacz sekcję "Używanie obiektu implementującego interfejs IDisposable" w temacie dotyczącym IDisposable interfejsu.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Możesz użyć metody, WaitHandle.WaitOne Aby zażądać własności obiektu mutex.You can use the WaitHandle.WaitOne method to request ownership of a mutex. Bloki wywołujące wątki do jednego z następujących wystąpień:The calling thread blocks until one of the following occurs:

  • Element mutex jest sygnalizowane sygnalizowaniem wskazującym, że nie jest własnością.The mutex is signaled to indicate that it is not owned. W takim przypadku WaitOne Metoda zwraca true , a wątek wywołujący przyjmuje własność obiektu mutex i uzyskuje dostęp do zasobu chronionego przez mutex.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. Po zakończeniu uzyskiwania dostępu do zasobu wątek musi wywołać ReleaseMutex metodę, aby zwolnić własność obiektu mutex.When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. Pierwszy przykład w sekcji Przykłady ilustruje ten wzorzec.The first example in the Examples section illustrates this pattern.

  • Przekroczono limit czasu określony w wywołaniu WaitOne metody, która ma millisecondsTimeout timeout parametr lub.The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. Gdy tak się stanie, WaitOne Metoda zwraca false , a wątek wywołujący nie podejmuje dalszej próby uzyskania własności obiektu mutex.When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. W takim przypadku należy zapewnić strukturę kodu tak, aby dostęp do zasobu, który jest chroniony przez mutex, został odrzucony do wątku wywołującego.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. Ponieważ wątek nigdy nie uzyskał własności elementu mutex, nie może wywołać ReleaseMutex metody.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. Drugi przykład w sekcji Przykłady ilustruje ten wzorzec.The second example in the Examples section illustrates this pattern.

MutexKlasa wymusza tożsamość wątku, więc element mutex może być wydawany tylko przez wątek, który go pozyskuje.The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. Z kolei Klasa nie Semaphore wymusza tożsamości wątku.By contrast, the Semaphore class does not enforce thread identity. Element mutex może być również przekazywać między granicami domeny aplikacji.A mutex can also be passed across application domain boundaries.

Wątek, który jest właścicielem obiektu mutex, może zażądać tego samego obiektu mutex w powtórzonych wywołaniach do WaitOne bez blokowania jego wykonywania.The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. Jednak wątek musi wywołać ReleaseMutex metodę o tej samej liczbie razy, aby zwolnić własność obiektu mutex.However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

Ponieważ Mutex Klasa dziedziczy z WaitHandle , można również wywołać metody statyczne i, WaitHandle.WaitAll WaitHandle.WaitAny Aby zsynchronizować dostęp do chronionego zasobu.Because 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.

Jeśli wątek kończy się, będąc właścicielem obiektu mutex, element mutex zostanie wskazany jako porzucony.If a thread terminates while owning a mutex, the mutex is said to be abandoned. Stan obiektu mutex jest ustawiony na sygnalizowanie, a następny oczekujący wątek pobiera własność.The state of the mutex is set to signaled, and the next waiting thread gets ownership. Począwszy od wersji 2,0 .NET Framework, AbandonedMutexException zostanie zgłoszony w następnym wątku, który uzyskuje porzucony obiekt mutex.Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. Przed wersją 2,0 .NET Framework nie został zgłoszony żaden wyjątek.Before version 2.0 of the .NET Framework, no exception was thrown.

Przestroga

Porzucony obiekt mutex często wskazuje poważny błąd w kodzie.An abandoned mutex often indicates a serious error in the code. Gdy wątek zostanie zakończony bez zwalniania obiektu mutex, struktury danych chronione przez element Mutex mogą nie być w stanie spójności.When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. Następny wątek do żądania własności obiektu mutex może obsłużyć ten wyjątek i postępować, jeśli można zweryfikować integralność struktur danych.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.

W przypadku obiektu mutex w całym systemie porzucony obiekt mutex może wskazywać, że aplikacja została zakończona nieoczekiwanie (na przykład za pomocą Menedżera zadań systemu 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).

Muteksy są dwa typy: lokalne muteksy, które są nienazwane i nazwane muteksy systemowe.Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. Lokalny element mutex istnieje tylko w ramach procesu.A local mutex exists only within your process. Może być używany przez dowolny wątek w procesie, który zawiera odwołanie do Mutex obiektu, który reprezentuje element mutex.It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Każdy obiekt bez nazwy Mutex reprezentuje oddzielny lokalny element mutex.Each unnamed Mutex object represents a separate local mutex.

Nazwane muteksy systemu są widoczne w całym systemie operacyjnym i mogą być używane do synchronizowania działań procesów.Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. Można utworzyć Mutex obiekt reprezentujący nazwany element mutex systemu przy użyciu konstruktora, który akceptuje nazwę.You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. Obiekt systemu operacyjnego można utworzyć w tym samym czasie lub może istnieć przed utworzeniem Mutex obiektu.The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. Można utworzyć wiele Mutex obiektów, które reprezentują ten sam nazwany obiekt mutex, i można użyć metody, OpenExisting Aby otworzyć istniejący nazwany element mutex systemu.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.

Uwaga

Na serwerze, na którym są uruchomione usługi terminalowe, nazwany element mutex systemu może mieć dwa poziomy widoczności.On a server that is running Terminal Services, a named system mutex can have two levels of visibility. Jeśli nazwa zaczyna się od prefiksu "Global \ ", element mutex jest widoczny we wszystkich sesjach serwera terminali.If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. Jeśli nazwa zaczyna się od prefiksu "Local \ ", mutex jest widoczny tylko w sesji serwera terminali, w której został utworzony.If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. W takim przypadku na serwerze może istnieć oddzielny obiekt mutex o tej samej nazwie.In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. Jeśli nie określisz prefiksu podczas tworzenia nazwanego obiektu mutex, przyjmuje prefiks "Local \ ".If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". W sesji serwera terminali dwa muteksy, których nazwy różnią się tylko prefiksami, są oddzielnymi muteksami, a oba są widoczne dla wszystkich procesów w sesji serwera terminali.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. Oznacza to, że nazwy prefiksów "globalne \ " i "lokalne \ " opisują zakres nazwy obiektu mutex względem sesji serwera terminali, a nie względem procesów.That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

Ukośnik odwrotny ( \ ) jest znakiem zastrzeżonym w nazwie obiektu mutex.The backslash (\) is a reserved character in a mutex name. Nie należy używać ukośnika odwrotnego ( \ ) w nazwie obiektu mutex, z wyjątkiem sytuacji, w której jest określony w notatce przy użyciu muteksów w sesjach serwera terminali.Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. W przeciwnym razie DirectoryNotFoundException może być zgłaszane, nawet jeśli nazwa obiektu mutex reprezentuje istniejący plik.Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

Konstruktory

Mutex()

Inicjuje nowe wystąpienie Mutex klasy z właściwościami domyślnymi.Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean)

Inicjuje nowe wystąpienie Mutex klasy z wartością logiczną, która wskazuje, czy wątek wywołujący powinien mieć wstępną własność obiektu 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)

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ść obiektu mutex, oraz ciąg, który jest nazwą obiektu 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)

Inicjuje nowe wystąpienie Mutex klasy za pomocą wartości logicznej wskazującej, czy wątek wywołujący powinien mieć początkową własność obiektu mutex, ciąg, który jest nazwą obiektu mutex, i wartość logiczną, która po powrocie metody wskazuje, czy wątek wywołujący otrzymał początkową własność obiektu 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)

Inicjuje nowe wystąpienie Mutex klasy za pomocą wartości logicznej wskazującej, czy wątek wywołujący powinien mieć początkową własność obiektu mutex, ciąg, który jest nazwą obiektu mutex, zmienną logiczną, która po powrocie metody wskazuje, czy wątek wywołujący otrzymał początkową własność obiektu mutex, a zabezpieczenia kontroli dostępu mają być stosowane do nazwanego obiektu 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.

Pola

WaitTimeout

Wskazuje, że WaitAny(WaitHandle[], Int32, Boolean) upłynął limit czasu operacji przed zasygnalizowaniem dowolnego z dojść oczekiwania.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. To pole jest stałe.This field is constant.

(Odziedziczone po WaitHandle)

Właściwości

Handle
Nieaktualne.

Pobiera lub ustawia natywne dojście systemu operacyjnego.Gets or sets the native operating system handle.

(Odziedziczone po WaitHandle)
SafeWaitHandle

Pobiera lub ustawia natywne dojście systemu operacyjnego.Gets or sets the native operating system handle.

(Odziedziczone po WaitHandle)

Metody

Close()

Zwalnia wszystkie zasoby przechowywane przez bieżące WaitHandle .Releases all resources held by the current WaitHandle.

(Odziedziczone po WaitHandle)
CreateObjRef(Type)

Tworzy obiekt, który zawiera wszystkie istotne informacje wymagane do wygenerowania serwera proxy używanego do komunikacji z obiektem zdalnym.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Odziedziczone po MarshalByRefObject)
Dispose()

Zwalnia wszystkie zasoby używane przez bieżące wystąpienie klasy WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Odziedziczone po WaitHandle)
Dispose(Boolean)

Gdy jest zastępowany w klasie pochodnej, zwalnia niezarządzane zasoby używane przez WaitHandle program i opcjonalnie zwalnia zarządzane zasoby.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Odziedziczone po WaitHandle)
Equals(Object)

Określa, czy dany obiekt jest taki sam, jak bieżący obiekt.Determines whether the specified object is equal to the current object.

(Odziedziczone po Object)
GetAccessControl()

Pobiera MutexSecurity obiekt reprezentujący zabezpieczenia kontroli dostępu dla nazwanego obiektu mutex.Gets a MutexSecurity object that represents the access control security for the named mutex.

GetHashCode()

Służy jako domyślna funkcja skrótu.Serves as the default hash function.

(Odziedziczone po Object)
GetLifetimeService()

Pobiera bieżący obiekt usługi okresu istnienia, który kontroluje zasady okresu istnienia dla tego wystąpienia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
GetType()

Pobiera Type bieżące wystąpienie.Gets the Type of the current instance.

(Odziedziczone po Object)
InitializeLifetimeService()

Uzyskuje obiekt usługi istnienia w celu kontrolowania zasad okresu istnienia dla tego wystąpienia.Obtains a lifetime service object to control the lifetime policy for this instance.

(Odziedziczone po MarshalByRefObject)
MemberwiseClone()

Tworzy skróconą kopię bieżącego elementu Object .Creates a shallow copy of the current Object.

(Odziedziczone po Object)
MemberwiseClone(Boolean)

Tworzy skróconą kopię bieżącego MarshalByRefObject obiektu.Creates a shallow copy of the current MarshalByRefObject object.

(Odziedziczone po MarshalByRefObject)
OpenExisting(String)

Otwiera określony nazwany mutex, jeśli już istnieje.Opens the specified named mutex, if it already exists.

OpenExisting(String, MutexRights)

Otwiera określony nazwany mutex, jeśli już istnieje, z żądanym dostępem zabezpieczeń.Opens the specified named mutex, if it already exists, with the desired security access.

ReleaseMutex()

Zwalnia Mutex jeden raz.Releases the Mutex once.

SetAccessControl(MutexSecurity)

Ustawia zabezpieczenia kontroli dostępu dla nazwanego muteksu systemowego.Sets the access control security for a named system mutex.

ToString()

Zwraca ciąg reprezentujący bieżący obiekt.Returns a string that represents the current object.

(Odziedziczone po Object)
TryOpenExisting(String, Mutex)

Otwiera określony nazwany obiekt mutex, jeśli już istnieje, i zwraca wartość wskazującą, czy operacja zakończyła się pomyślnie.Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, MutexRights, Mutex)

Otwiera określony nazwany obiekt mutex, jeśli już istnieje, z żądanym dostępem zabezpieczeń i zwraca wartość wskazującą, czy operacja zakończyła się pomyślnie.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()

Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału.Blocks the current thread until the current WaitHandle receives a signal.

(Odziedziczone po WaitHandle)
WaitOne(Int32)

Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej podpisanej liczby całkowitej w celu określenia interwału czasu w milisekundach.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Odziedziczone po WaitHandle)
WaitOne(Int32, Boolean)

Blokuje bieżący wątek do momentu WaitHandle odebrania sygnału przy użyciu 32-bitowej podpisanej liczby całkowitej w celu określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji przed oczekiwaniem.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.

(Odziedziczone po WaitHandle)
WaitOne(TimeSpan)

Blokuje bieżący wątek do momentu otrzymania przez bieżące wystąpienie sygnału przy użyciu TimeSpan do określenia interwału czasu.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Odziedziczone po WaitHandle)
WaitOne(TimeSpan, Boolean)

Blokuje bieżący wątek do momentu odebrania przez bieżące wystąpienie sygnału przy użyciu TimeSpan do określenia interwału czasu i określenia, czy zamknąć domenę synchronizacji przed oczekiwaniem.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.

(Odziedziczone po WaitHandle)

Jawne implementacje interfejsu

IDisposable.Dispose()

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

Zwalnia wszelkie zasoby używane przez element WaitHandle.Releases all resources used by the WaitHandle.

(Odziedziczone po WaitHandle)

Metody rozszerzania

GetAccessControl(Mutex)

Zwraca deskryptory zabezpieczeń dla określonego elementu mutex .Returns the security descriptors for the specified mutex.

SetAccessControl(Mutex, MutexSecurity)

Ustawia deskryptory zabezpieczeń dla określonego obiektu mutex.Sets the security descriptors for the specified mutex.

GetSafeWaitHandle(WaitHandle)

Pobiera Bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Ustawia Bezpieczny uchwyt dla natywnego uchwytu oczekiwania systemu operacyjnego.Sets a safe handle for a native operating system wait handle.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.This type is thread safe.

Zobacz też