Mutex Classe

Definição

Um primitivo de sincronização que também pode ser usado para sincronização entre processos.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
Herança
Atributos

Exemplos

Este exemplo mostra como um objeto Mutex local é usado para sincronizar o acesso a um recurso protegido.This example shows how a local Mutex object is used to synchronize access to a protected resource. Como cada thread de chamada é bloqueado até que ele adquira a propriedade do mutex, ele deve chamar ReleaseMutex o método para liberar a propriedade do thread.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

No exemplo a seguir, cada thread chama o WaitOne(Int32) método para adquirir o mutex.In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. Se o intervalo de tempo limite expirar, o método retorna falsee o thread não adquire o mutex nem obtém acesso ao recurso que o mutex protege.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. O ReleaseMutex método é chamado somente pelo thread que adquire o 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

Comentários

Quando dois ou mais threads precisam acessar um recurso compartilhado ao mesmo tempo, o sistema precisa de um mecanismo de sincronização para garantir que apenas um thread de cada vez use o recurso.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é um primitivo de sincronização que concede acesso exclusivo ao recurso compartilhado para apenas um thread.Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. Se um thread adquire um mutex, o segundo thread que deseja adquirir esse mutex é suspenso até que o primeiro thread libere o 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.

Importante

Esse tipo implementa a interface IDisposable.This type implements the IDisposable interface. Quando você terminar de usar o tipo, deverá descartá-lo direta ou indiretamente.When you have finished using the type, you should dispose of it either directly or indirectly. Para descartar o tipo diretamente, chame o método Dispose dele em um bloco try/catch.To dispose of the type directly, call its Dispose method in a try/catch block. Para descartá-lo indiretamente, use um constructo de linguagem como using ( em C#) ou Using (em Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Saiba mais na seção "Como usar um objeto que implementa IDisposable" no tópico da interface IDisposable.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Você pode usar o WaitHandle.WaitOne método para solicitar a propriedade de um mutex.You can use the WaitHandle.WaitOne method to request ownership of a mutex. O thread de chamada é bloqueado até uma das seguintes situações:The calling thread blocks until one of the following occurs:

  • O mutex é sinalizado para indicar que ele não é proprietário.The mutex is signaled to indicate that it is not owned. Quando isso acontece, o WaitOne método retorna true, e o thread de chamada assume a propriedade do mutex e acessa o recurso protegido pelo 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. Quando o acesso ao recurso é concluído, o thread deve chamar o ReleaseMutex método para liberar a propriedade do mutex.When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. O primeiro exemplo na seção de exemplos ilustra esse padrão.The first example in the Examples section illustrates this pattern.

  • O intervalo de tempo limite especificado na chamada a um WaitOne método que tem um millisecondsTimeout parâmetro ou timeout foi decorrido.The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. Quando isso acontece, o WaitOne método retorna falsee o thread de chamada não faz mais nenhuma tentativa de adquirir a propriedade do mutex.When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. Nesse caso, você deve estruturar seu código para que o acesso ao recurso protegido pelo mutex seja negado ao thread de chamada.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. Como o thread nunca adquiriu a propriedade do mutex, ele não deve chamar ReleaseMutex o método.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. O segundo exemplo na seção de exemplos ilustra esse padrão.The second example in the Examples section illustrates this pattern.

A Mutex classe impõe a identidade do thread, de modo que um mutex pode ser liberado somente pelo thread que o adquiriu.The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. Por outro lado, Semaphore a classe não impõe a identidade do thread.By contrast, the Semaphore class does not enforce thread identity. Um mutex também pode ser passado entre limites de domínio do aplicativo.A mutex can also be passed across application domain boundaries.

O thread que possui um mutex pode solicitar o mesmo mutex em chamadas repetidas WaitOne para sem bloquear sua execução.The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. No entanto, o thread deve ReleaseMutex chamar o método o mesmo número de vezes para liberar a propriedade do mutex.However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

Como a Mutex classe herda de WaitHandle, você também pode chamar os métodos WaitHandle.WaitAll estáticos e WaitHandle.WaitAny para sincronizar o acesso a um recurso protegido.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.

Se um thread termina enquanto possui um mutex, o mutex é dito como abandonado.If a thread terminates while owning a mutex, the mutex is said to be abandoned. O estado do mutex é definido como signaled e o próximo thread em espera Obtém a propriedade.The state of the mutex is set to signaled, and the next waiting thread gets ownership. A partir da versão 2,0 do .NET Framework, um AbandonedMutexException é lançado no próximo thread que adquire o mutex abandonado.Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. Antes da versão 2,0 do .NET Framework, nenhuma exceção foi lançada.Before version 2.0 of the .NET Framework, no exception was thrown.

Cuidado

Um mutex abandonado geralmente indica um erro sério no código.An abandoned mutex often indicates a serious error in the code. Quando um thread sai sem liberar o mutex, as estruturas de dados protegidas pelo mutex podem não estar em um estado consistente.When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. O próximo thread para solicitar a propriedade do mutex pode lidar com essa exceção e continuar, se a integridade das estruturas de dados puder ser verificada.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.

No caso de um mutex de todo o sistema, um mutex abandonado pode indicar que um aplicativo foi finalizado abruptamente (por exemplo, usando o Gerenciador de Tarefas do 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).

Os mutexs são de dois tipos: mutexes locais, que são sem nome e mutexes de sistema nomeados.Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. Um mutex local existe somente dentro de seu processo.A local mutex exists only within your process. Ele pode ser usado por qualquer thread em seu processo que tenha uma referência ao Mutex objeto que representa o mutex.It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Cada Mutex objeto sem nome representa um mutex local separado.Each unnamed Mutex object represents a separate local mutex.

Os mutexes de sistema nomeados são visíveis em todo o sistema operacional e podem ser usados para sincronizar as atividades de processos.Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. Você pode criar um Mutex objeto que representa um mutex de sistema nomeado usando um construtor que aceita um nome.You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. O objeto do sistema operacional pode ser criado ao mesmo tempo ou pode existir antes da criação do Mutex objeto.The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. Você pode criar vários objetos Mutex que representam o mesmo mutex de sistema nomeado, e você pode usar o método OpenExisting para abrir um mutex de sistema nomeado existente.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.

Observação

Em um servidor que está executando os serviços de terminal, um mutex de sistema nomeado pode ter dois níveis de visibilidade.On a server that is running Terminal Services, a named system mutex can have two levels of visibility. Se seu nome começar com o prefixo "global\", o mutex será visível em todas as sessões do Terminal Server.If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. Se seu nome começar com o prefixo "local\", o mutex estará visível somente na sessão do Terminal Server em que foi criado.If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. Nesse caso, um mutex separado com o mesmo nome pode existir em cada uma das outras sessões do Terminal Server no servidor.In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. Se você não especificar um prefixo ao criar um mutex nomeado, ele usará o prefixo "local\".If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". Em uma sessão do Terminal Server, dois mutexes cujos nomes diferem somente por seus prefixos são mutexes separados e ambos ficam visíveis para todos os processos na sessão do Terminal Server.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. Ou seja, os nomes de prefixo "\global" e "\local" descrevem o escopo do nome do mutex em relação às sessões do Terminal Server, não em relação aos processos.That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

A barra invertida (\) é um caractere reservado em um nome de mutex.The backslash (\) is a reserved character in a mutex name. Não use uma barra invertida (\) em um nome de mutex, exceto conforme especificado na observação sobre como usar mutexes nas sessões do servidor de terminal.Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. Caso contrário, uma DirectoryNotFoundException pode ser gerada, mesmo que o nome do mutex represente um arquivo existente.Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

Construtores

Mutex()

Inicializa uma nova instância da classe Mutex com propriedades padrão.Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean)

Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter a propriedade inicial do 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)

Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter uma propriedade inicial do mutex e uma cadeia de caracteres que é o nome do 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)

Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter a propriedade inicial de mutex, uma cadeia de caracteres que é o nome do mutex e um valor booliano que, quando o método retorna, indica se o thread de chamada foi concedido a propriedade inicial do 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)

Inicializa uma nova instância da classe Mutex com um valor booliano que indica se o thread de chamada deve ter a propriedade inicial de mutex, uma cadeia de caracteres que é o nome do mutex, uma variável booliana que, quando o método retorna, indica se o thread de chamada foi concedido a propriedade inicial de mutex e a segurança de controle de acesso a ser aplicado ao mutex nomeado.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.

Campos

WaitTimeout

Indica que uma operação WaitAny(WaitHandle[], Int32, Boolean) atingiu o tempo limite antes que algum dos identificadores de espera fosse sinalizado.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Este campo é constante.This field is constant.

(Herdado de WaitHandle)

Propriedades

Handle

Obtém ou define o identificador de sistema operacional nativo.Gets or sets the native operating system handle.

(Herdado de WaitHandle)
SafeWaitHandle

Obtém ou define o identificador de sistema operacional nativo.Gets or sets the native operating system handle.

(Herdado de WaitHandle)

Métodos

Close()

Libera todos os recursos mantidos pelo WaitHandle atual.Releases all resources held by the current WaitHandle.

(Herdado de WaitHandle)
CreateObjRef(Type)

Cria um objeto que contém todas as informações relevantes necessárias para gerar um proxy usado para se comunicar com um objeto remoto.Creates an object that contains all the relevant information required to generate a proxy used to communicate with a remote object.

(Herdado de MarshalByRefObject)
Dispose()

Libera todos os recursos usados pela instância atual da classe WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Herdado de WaitHandle)
Dispose(Boolean)

Quando substituído em uma classe derivada, libera os recursos não gerenciados usados pelo WaitHandle e, opcionalmente, libera os recursos gerenciados.When overridden in a derived class, releases the unmanaged resources used by the WaitHandle, and optionally releases the managed resources.

(Herdado de WaitHandle)
Equals(Object)

Determina se o objeto especificado é igual ao objeto atual.Determines whether the specified object is equal to the current object.

(Herdado de Object)
GetAccessControl()

Obtém um objeto MutexSecurity que representa a segurança do controle de acesso para o mutex nomeado.Gets a MutexSecurity object that represents the access control security for the named mutex.

GetHashCode()

Serve como a função de hash padrão.Serves as the default hash function.

(Herdado de Object)
GetLifetimeService()

Recupera o objeto de serviço de tempo de vida atual que controla a política de ciclo de vida para esta instância.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

(Herdado de MarshalByRefObject)
GetType()

Obtém o Type da instância atual.Gets the Type of the current instance.

(Herdado de Object)
InitializeLifetimeService()

Obtém um objeto de serviço de tempo de vida para controlar a política de tempo de vida para essa instância.Obtains a lifetime service object to control the lifetime policy for this instance.

(Herdado de MarshalByRefObject)
MemberwiseClone()

Cria uma cópia superficial do Object atual.Creates a shallow copy of the current Object.

(Herdado de Object)
MemberwiseClone(Boolean)

Cria uma cópia superficial do objeto MarshalByRefObject atual.Creates a shallow copy of the current MarshalByRefObject object.

(Herdado de MarshalByRefObject)
OpenExisting(String)

Abre o mutex nomeado especificado, caso ele já exista.Opens the specified named mutex, if it already exists.

OpenExisting(String, MutexRights)

Abre o mutex nomeado especificado, caso ele já exista, com o acesso de segurança desejado.Opens the specified named mutex, if it already exists, with the desired security access.

ReleaseMutex()

Libera o Mutex uma vez.Releases the Mutex once.

SetAccessControl(MutexSecurity)

Define a segurança de controle de acesso para um mutex de sistema nomeado.Sets the access control security for a named system mutex.

ToString()

Retorna uma cadeia de caracteres que representa o objeto atual.Returns a string that represents the current object.

(Herdado de Object)
TryOpenExisting(String, Mutex)

Abre o mutex nomeado especificado, quando ele já existe e retorna um valor que indica se a operação foi bem-sucedida.Opens the specified named mutex, if it already exists, and returns a value that indicates whether the operation succeeded.

TryOpenExisting(String, MutexRights, Mutex)

Se o mutex nomeado especificado já existe, abre-o com o acesso de segurança desejado e retorna um valor que indica se a operação foi bem-sucedida.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()

Bloqueia o thread atual até que o WaitHandle atual receba um sinal.Blocks the current thread until the current WaitHandle receives a signal.

(Herdado de WaitHandle)
WaitOne(Int32)

Bloqueia o thread atual até que o WaitHandle atual receba um sinal, usando um inteiro com sinal de 32 bits para especificar o intervalo de tempo em milissegundos.Blocks the current thread until the current WaitHandle receives a signal, using a 32-bit signed integer to specify the time interval in milliseconds.

(Herdado de WaitHandle)
WaitOne(Int32, Boolean)

Bloqueia o thread atual até que o WaitHandle atual receba um sinal, usando um inteiro com sinal de 32 bits para especificar o intervalo de tempo e especificar se sairá do domínio de sincronização antes da espera.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.

(Herdado de WaitHandle)
WaitOne(TimeSpan)

Bloqueia o thread atual até que a instância atual receba um sinal, usando um TimeSpan para especificar o intervalo de tempo.Blocks the current thread until the current instance receives a signal, using a TimeSpan to specify the time interval.

(Herdado de WaitHandle)
WaitOne(TimeSpan, Boolean)

Bloqueia o thread atual até que a instância atual receba um sinal, usando um TimeSpan para especificar o intervalo de tempo e especificar se sairá do domínio de sincronização antes da espera.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.

(Herdado de WaitHandle)

Implantações explícitas de interface

IDisposable.Dispose()

Libera todos os recursos usados pelo WaitHandle.Releases all resources used by the WaitHandle.

(Herdado de WaitHandle)

Métodos de Extensão

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

Obtém o identificador seguro para um identificador de espera nativo do sistema operacional.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Define um identificador seguro para um identificador de espera do sistema operacional nativo.Sets a safe handle for a native operating system wait handle.

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Veja também