Mutex Mutex Mutex Mutex Class

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 local Mutex objeto é 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 adquire a propriedade do mutex, ela deve chamar o ReleaseMutex 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 expira, o método retorna false, e o thread não adquire o mutex nem obtém acesso ao recurso protege o mutex.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 por 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 é uma sincronização primitiva que concede acesso exclusivo ao recurso compartilhado a um único 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 quiser adquirir essa exclusão mútua é suspenso até que o primeiro thread libera 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 o IDisposable interface.This type implements the IDisposable interface. Quando você terminar de usar o tipo, você deve descartá-lo diretamente ou indiretamente.When you have finished using the type, you should dispose of it either directly or indirectly. Para descartar o tipo diretamente, chame seu Dispose método em um try / catch bloco.To dispose of the type directly, call its Dispose method in a try/catch block. Para descartá-los indiretamente, usar uma construção de linguagem, como using (em c#) ou Using (no Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Para obter mais informações, consulte a seção "Usando um objeto que implementa IDisposable" o IDisposable tópico da interface.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 chamada thread bloqueia até que ocorra um dos seguintes:The calling thread blocks until one of the following occurs:

  • O mutex será sinalizado para indicar que ele não pertence.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 tiver concluído a acessar o recurso, 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 exemplos ilustra esse padrão.The first example in the Examples section illustrates this pattern.

  • O intervalo de tempo limite especificado na chamada para um WaitOne método que tem um millisecondsTimeout ou timeout parâmetro tiver 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 false, e nenhuma outra tentativa de adquirir a propriedade do mutex faz com que o thread de chamada.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 que é protegido pelo mutex é negado para o 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 o ReleaseMutex método.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. O segundo exemplo na seção exemplos ilustra esse padrão.The second example in the Examples section illustrates this pattern.

O Mutex classe impõe a identidade do thread, portanto, 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, o Semaphore 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 de 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 para WaitOne sem bloquear a 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 chamar o ReleaseMutex 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.

Porque o Mutex herda WaitHandle, você também pode chamar estático WaitHandle.WaitAll e WaitHandle.WaitAny métodos 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 é encerrado enquanto for proprietário de um mutex, será considerado o mutex abandonado.If a thread terminates while owning a mutex, the mutex is said to be abandoned. O estado do mutex é definido como sinalizado e o próxima thread em espera obtém a propriedade.The state of the mutex is set to signaled, and the next waiting thread gets ownership. Começando na versão 2.0 do .NET Framework, um AbandonedMutexException é gerada 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 grave no código.An abandoned mutex often indicates a serious error in the code. Quando um thread é encerrado sem liberar o mutex, as estruturas de dados protegidas pelo mutex podem não ser 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 a solicitar a propriedade do mutex pode tratar essa exceção e continuar, se a integridade das estruturas de dados pode 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).

Mutexes são de dois tipos: mutexes locais, que são e sem-nome mutexes de sistema.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 no processo que tem uma referência para o 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 sem nome Mutex objeto representa um mutex local separado.Each unnamed Mutex object represents a separate local mutex.

Do sistema nomeado mutexes são visíveis em todo o sistema operacional e pode 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 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 esteja executando serviços de Terminal, um mutex nomeado do sistema 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 o nome começa com o prefixo "Global\", o mutex está 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 o nome começa com o prefixo "Local\", o mutex está visível somente na sessão do terminal server no qual ele 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 usa o prefixo "Local\".If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". Dentro de uma sessão de servidor de terminal, dois mutexes cujos nomes diferem apenas por seus prefixos são mutexes separado e ambos são 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 a sessões do terminal server, não em relação a 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() Mutex() Mutex() 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) Mutex(Boolean) Mutex(Boolean) 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) Mutex(Boolean, String) Mutex(Boolean, String) 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) Mutex(Boolean, String, Boolean) Mutex(Boolean, String, Boolean) 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) Mutex(Boolean, String, Boolean, MutexSecurity) Mutex(Boolean, String, Boolean, MutexSecurity) 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.

Métodos

Close() Close() Close() Close()

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

(Inherited from WaitHandle)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) 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.

(Inherited from MarshalByRefObject)
Dispose() Dispose() Dispose() 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.

(Inherited from WaitHandle)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) 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.

(Inherited from WaitHandle)
Equals(Object) Equals(Object) Equals(Object) Equals(Object)

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

(Inherited from Object)
GetAccessControl() GetAccessControl() GetAccessControl() 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() GetHashCode() GetHashCode() GetHashCode()

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

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() 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.

(Inherited from MarshalByRefObject)
GetType() GetType() GetType() GetType()

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

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() 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.

(Inherited from MarshalByRefObject)
MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

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

(Inherited from Object)
MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean) MemberwiseClone(Boolean)

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

(Inherited from MarshalByRefObject)
OpenExisting(String) OpenExisting(String) OpenExisting(String) OpenExisting(String)

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

OpenExisting(String, MutexRights) OpenExisting(String, MutexRights) OpenExisting(String, MutexRights) 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() ReleaseMutex() ReleaseMutex() ReleaseMutex()

Libera o Mutex uma vez.Releases the Mutex once.

SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity) 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() ToString() ToString() ToString()

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

(Inherited from Object)
TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex) 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) TryOpenExisting(String, MutexRights, Mutex) TryOpenExisting(String, MutexRights, Mutex) 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() WaitOne() WaitOne() WaitOne()

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

(Inherited from WaitHandle)
WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) 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.

(Inherited from WaitHandle)
WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) WaitOne(Int32, Boolean) 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.

(Inherited from WaitHandle)
WaitOne(TimeSpan) WaitOne(TimeSpan) WaitOne(TimeSpan) 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.

(Inherited from WaitHandle)
WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) WaitOne(TimeSpan, Boolean) 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.

(Inherited from WaitHandle)

Propriedades

Handle Handle Handle Handle

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

(Inherited from WaitHandle)
SafeWaitHandle SafeWaitHandle SafeWaitHandle SafeWaitHandle

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

(Inherited from WaitHandle)

Implantações explícitas de interface

IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose() IDisposable.Dispose()

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

(Inherited from WaitHandle)

Campos

WaitTimeout WaitTimeout WaitTimeout 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.

(Inherited from WaitHandle)

Métodos de Extensão

GetAccessControl(Mutex) GetAccessControl(Mutex) GetAccessControl(Mutex) GetAccessControl(Mutex)
SetAccessControl(Mutex, MutexSecurity) SetAccessControl(Mutex, MutexSecurity) SetAccessControl(Mutex, MutexSecurity) SetAccessControl(Mutex, MutexSecurity)
GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) GetSafeWaitHandle(WaitHandle) 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) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) 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