Mutex Mutex Mutex Mutex Class

Definición

Primitiva de sincronización que puede usarse también para la sincronización entre procesos.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
Herencia
Atributos

Ejemplos

Este ejemplo se muestra cómo una variable local Mutex objeto se usa para sincronizar el acceso a un recurso protegido.This example shows how a local Mutex object is used to synchronize access to a protected resource. Dado que cada subproceso que realiza la llamada se bloquea hasta que obtiene la propiedad de la exclusión mutua, debe llamar a la ReleaseMutex método para liberar la propiedad del subproceso.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

En el ejemplo siguiente, cada subproceso llama a la WaitOne(Int32) método para adquirir la exclusión mutua.In the following example, each thread calls the WaitOne(Int32) method to acquire the mutex. Si transcurre el intervalo de tiempo de espera, el método devuelve false, y el subproceso no adquiere la exclusión mutua ni obtiene acceso al recurso que protege la exclusión mutua.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. El ReleaseMutex se llama al método sólo por el subproceso que adquiere la exclusión mutua.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

Comentarios

Cuando dos o más subprocesos deben tener acceso a un recurso compartido al mismo tiempo, el sistema necesita un mecanismo de sincronización para asegurarse de que solo un subproceso a la vez usa el 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 es una sincronización primitiva que concede acceso exclusivo al recurso compartido a un solo subproceso.Mutex is a synchronization primitive that grants exclusive access to the shared resource to only one thread. Si un subproceso adquiere una exclusión mutua, el segundo subproceso que desea adquirir la exclusión mutua del que se suspende hasta que el primer subproceso libera la exclusión mutua.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

Este tipo implementa la IDisposable interfaz.This type implements the IDisposable interface. Cuando haya terminado de utilizar el tipo, debe deshacerse de él directa o indirectamente.When you have finished using the type, you should dispose of it either directly or indirectly. Para deshacerse del tipo directamente, llame a su Dispose método en un try / catch bloque.To dispose of the type directly, call its Dispose method in a try/catch block. Para deshacerse de él, indirectamente, usar una construcción de lenguaje, como using (en C#) o Using (en Visual Basic).To dispose of it indirectly, use a language construct such as using (in C#) or Using (in Visual Basic). Para obtener más información, vea la sección "Uso de un objeto que implementa IDisposable" en el IDisposable tema de la interfaz.For more information, see the "Using an Object that Implements IDisposable" section in the IDisposable interface topic.

Puede usar el WaitHandle.WaitOne método para solicitar la propiedad de una exclusión mutua.You can use the WaitHandle.WaitOne method to request ownership of a mutex. El subproceso que realiza la llamada se bloquea hasta que se produzca uno de los siguientes:The calling thread blocks until one of the following occurs:

  • La exclusión mutua se señala para indicar que no pertenece.The mutex is signaled to indicate that it is not owned. Cuando esto sucede, el WaitOne devuelve del método true, y el subproceso de llamada asume la propiedad de la exclusión mutua y accede al recurso protegido por la exclusión mutua.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. Cuando haya terminado de obtener acceso al recurso, el subproceso debe llamar a la ReleaseMutex método para liberar la propiedad de la exclusión mutua.When it has finished accessing the resource, the thread must call the ReleaseMutex method to release ownership of the mutex. El primer ejemplo en la sección de ejemplos muestra este modelo.The first example in the Examples section illustrates this pattern.

  • El intervalo de tiempo de espera especificado en la llamada a un WaitOne método que tiene un millisecondsTimeout o timeout parámetro ha transcurrido.The time-out interval specified in the call to a WaitOne method that has a millisecondsTimeout or timeout parameter has elapsed. Cuando esto sucede, el WaitOne devuelve del método false, y el subproceso que realiza la llamada realiza ningún intento adicional para adquirir posesión de la exclusión mutua.When this happens, the WaitOne method returns false, and the calling thread makes no further attempt to acquire ownership of the mutex. En este caso, debe estructurar el código para que se deniega el acceso al recurso protegido por la exclusión mutua al subproceso que realiza la llamada.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. Dado que el subproceso nunca haya adquirido la propiedad de la exclusión mutua, no debe llamar el ReleaseMutex método.Because the thread never acquired ownership of the mutex, it must not call the ReleaseMutex method. El segundo ejemplo en la sección de ejemplos muestra este modelo.The second example in the Examples section illustrates this pattern.

La Mutex clase exige la identidad del subproceso, por lo que se puede liberar una exclusión mutua sólo por el subproceso que lo adquirió.The Mutex class enforces thread identity, so a mutex can be released only by the thread that acquired it. Por el contrario, el Semaphore clase no exige la identidad del subproceso.By contrast, the Semaphore class does not enforce thread identity. Una exclusión mutua también se puede pasar entre los límites del dominio de aplicación.A mutex can also be passed across application domain boundaries.

El subproceso que posee una exclusión mutua puede solicitar la misma exclusión mutua en llamadas repetidas a WaitOne sin bloquear su ejecución.The thread that owns a mutex can request the same mutex in repeated calls to WaitOne without blocking its execution. Sin embargo, el subproceso debe llamar a la ReleaseMutex método el mismo número de veces para liberar la propiedad de la exclusión mutua.However, the thread must call the ReleaseMutex method the same number of times to release ownership of the mutex.

Dado que el Mutex clase hereda de WaitHandle, también se puede llamar a estático WaitHandle.WaitAll y WaitHandle.WaitAny métodos para sincronizar el acceso a un 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.

Si un subproceso finaliza mientras posee una exclusión mutua, se dice que la exclusión mutua abandonada.If a thread terminates while owning a mutex, the mutex is said to be abandoned. El estado de la exclusión mutua se establece en señalado y el siguiente subproceso en espera obtiene la propiedad.The state of the mutex is set to signaled, and the next waiting thread gets ownership. A partir de la versión 2.0 de .NET Framework, un AbandonedMutexException se produce en el subproceso siguiente que adquiere la exclusión mutua abandonada.Beginning in version 2.0 of the .NET Framework, an AbandonedMutexException is thrown in the next thread that acquires the abandoned mutex. Antes de la versión 2.0 de .NET Framework, se produjo ninguna excepción.Before version 2.0 of the .NET Framework, no exception was thrown.

Precaución

A menudo, un mutex abandonado indica un error grave en el código.An abandoned mutex often indicates a serious error in the code. Cuando un subproceso sale sin liberar la exclusión mutua, las estructuras de datos protegidas por el mutex no esté en un estado coherente.When a thread exits without releasing the mutex, the data structures protected by the mutex might not be in a consistent state. El siguiente subproceso que solicita la propiedad de la exclusión mutua puede controlar esta excepción y continuar si se puede comprobar la integridad de las estructuras de datos.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.

En el caso de una exclusión mutua en todo el sistema, una exclusión mutua abandonada podría indicar que una aplicación finalizó inesperadamente (por ejemplo, con el Administrador de tareas de 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).

Las exclusiones mutuas son de dos tipos: exclusiones mutuas locales, que son y sin nombre exclusiones mutuas del sistema.Mutexes are of two types: local mutexes, which are unnamed, and named system mutexes. Una exclusión mutua local solo existe dentro del proceso.A local mutex exists only within your process. Se puede usar cualquier subproceso del proceso que tenga una referencia a la Mutex objeto que representa la exclusión mutua.It can be used by any thread in your process that has a reference to the Mutex object that represents the mutex. Cada uno sin nombre Mutex objeto representa una exclusión mutua local independiente.Each unnamed Mutex object represents a separate local mutex.

Las exclusiones mutuas son visibles en todo el sistema operativo y pueden utilizarse para sincronizar las actividades de procesos de sistema con nombre.Named system mutexes are visible throughout the operating system, and can be used to synchronize the activities of processes. Puede crear un Mutex objeto que representa una exclusión mutua del sistema con nombre mediante un constructor que acepta un nombre.You can create a Mutex object that represents a named system mutex by using a constructor that accepts a name. Se puede crear el objeto del sistema operativo al mismo tiempo, o puede existir antes de la creación de la Mutex objeto.The operating-system object can be created at the same time, or it can exist before the creation of the Mutex object. Puede crear varios objetos Mutex que representen la misma exclusión mutua del sistema con nombre y puede usar el método OpenExisting para abrir una exclusión mutua del sistema con nombre 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.

Nota

En un servidor que ejecuta Servicios de Terminal Server, una exclusión mutua del sistema con nombre puede tener dos niveles de visibilidad.On a server that is running Terminal Services, a named system mutex can have two levels of visibility. Si su nombre comienza con el prefijo "Global\", la exclusión mutua está visible en todas las sesiones de terminal server.If its name begins with the prefix "Global\", the mutex is visible in all terminal server sessions. Si su nombre comienza con el prefijo "Local\", la exclusión mutua solo es visible en la sesión de terminal server donde se creó.If its name begins with the prefix "Local\", the mutex is visible only in the terminal server session where it was created. En ese caso, puede existir una exclusión mutua independiente con el mismo nombre en cada una de las demás sesiones de terminal server en el servidor.In that case, a separate mutex with the same name can exist in each of the other terminal server sessions on the server. Si no especifica un prefijo al crear una exclusión mutua con nombre, toma el prefijo "Local\".If you do not specify a prefix when you create a named mutex, it takes the prefix "Local\". Dentro de una sesión de terminal server, dos exclusiones mutuas cuyos nombres difieren solo por sus prefijos son independientes de las exclusiones mutuas y ambos son visibles para todos los procesos en la sesión de 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. Es decir, los nombres de prefijo "Global\" y "Local\" describe el ámbito del nombre de exclusión mutua con respecto a las sesiones de terminal server, no en relación con los procesos.That is, the prefix names "Global\" and "Local\" describe the scope of the mutex name relative to terminal server sessions, not relative to processes.

La barra diagonal inversa (\) es un carácter reservado en un nombre de exclusión mutua.The backslash (\) is a reserved character in a mutex name. No use una barra diagonal inversa (\) en un nombre de exclusión mutua excepto como se especifica en la nota sobre el uso de exclusiones mutuas en sesiones de Terminal Server.Don't use a backslash (\) in a mutex name except as specified in the note on using mutexes in terminal server sessions. En caso contrario, es posible que se inicie una excepción DirectoryNotFoundException, aunque el nombre de la exclusión mutua represente un archivo existente.Otherwise, a DirectoryNotFoundException may be thrown, even though the name of the mutex represents an existing file.

Constructores

Mutex() Mutex() Mutex() Mutex()

Inicializa una nueva instancia de la clase Mutex con propiedades predeterminadas.Initializes a new instance of the Mutex class with default properties.

Mutex(Boolean) Mutex(Boolean) Mutex(Boolean) Mutex(Boolean)

Inicializa una nueva instancia de la clase Mutex con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua.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 una nueva instancia de la clase Mutex con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua y una cadena que representa el nombre de la exclusión mutua.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 una nueva instancia de la clase Mutex con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua, una cadena que es el nombre de la exclusión mutua y un valor booleano que, cuando se devuelva el método, indicará si se concedió la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada.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 una nueva instancia de la clase Mutex con un valor booleano que indica si el subproceso que realiza la llamada debe tener la propiedad inicial de la exclusión mutua; una cadena que es el nombre de la exclusión mutua; una variable booleana que, cuando se devuelva el método, indicará si se le concedió la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada; y la seguridad del control de acceso que se va a aplicar a la exclusión mutua con nombre.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 los recursos mantenidos por el objeto WaitHandle actual.Releases all resources held by the current WaitHandle.

(Inherited from WaitHandle)
CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type) CreateObjRef(Type)

Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un 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 los recursos usados por la instancia actual de la clase WaitHandle.Releases all resources used by the current instance of the WaitHandle class.

(Inherited from WaitHandle)
Dispose(Boolean) Dispose(Boolean) Dispose(Boolean) Dispose(Boolean)

Cuando se reemplaza en una clase derivada, libera los recursos no administrados que usa WaitHandle y, de forma opcional, libera los recursos administrados.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 si el objeto especificado es igual al objeto actual.Determines whether the specified object is equal to the current object.

(Inherited from Object)
GetAccessControl() GetAccessControl() GetAccessControl() GetAccessControl()

Obtiene un objeto MutexSecurity que representa la seguridad de control de acceso para la exclusión mutua con nombre.Gets a MutexSecurity object that represents the access control security for the named mutex.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Sirve como la función hash predeterminada.Serves as the default hash function.

(Inherited from Object)
GetLifetimeService() GetLifetimeService() GetLifetimeService() GetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.Retrieves the current lifetime service object that controls the lifetime policy for this instance.

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

Obtiene el Type de la instancia actual.Gets the Type of the current instance.

(Inherited from Object)
InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService() InitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.Obtains a lifetime service object to control the lifetime policy for this instance.

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

Crea una copia superficial del Object actual.Creates a shallow copy of the current Object.

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

Crea una copia superficial del objeto MarshalByRefObject actual.Creates a shallow copy of the current MarshalByRefObject object.

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

Abre la exclusión mutua con nombre especificada, si ya existe.Opens the specified named mutex, if it already exists.

OpenExisting(String, MutexRights) OpenExisting(String, MutexRights) OpenExisting(String, MutexRights) OpenExisting(String, MutexRights)

Abre la exclusión mutua con nombre especificada, si ya existe, con el acceso de seguridad deseado.Opens the specified named mutex, if it already exists, with the desired security access.

ReleaseMutex() ReleaseMutex() ReleaseMutex() ReleaseMutex()

Libera una vez la instancia de Mutex.Releases the Mutex once.

SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity) SetAccessControl(MutexSecurity)

Establece la seguridad de control de acceso para una exclusión mutua del sistema con nombre.Sets the access control security for a named system mutex.

ToString() ToString() ToString() ToString()

Devuelve una cadena que representa el objeto actual.Returns a string that represents the current object.

(Inherited from Object)
TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex) TryOpenExisting(String, Mutex)

Abre la exclusión mutua con nombre especificada, si ya existe, y devuelve un valor que indica si la operación se realizó correctamente.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)

Abre la exclusión mutua con nombre especificada, si ya existe, con el acceso de seguridad deseado y devuelve un valor que indica si la operación se realizó correctamente.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()

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal.Blocks the current thread until the current WaitHandle receives a signal.

(Inherited from WaitHandle)
WaitOne(Int32) WaitOne(Int32) WaitOne(Int32) WaitOne(Int32)

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, usando un entero de 32 bits con signo para especificar el intervalo de tiempo en milisegundos.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)

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal, usa un entero de 32 bits con signo para determinar el intervalo de tiempo y especifica si hay que salir del dominio de sincronización antes de la 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)

Bloquea el subproceso actual hasta que la instancia actual recibe una señal, usando TimeSpan para especificar el intervalo de tiempo.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)

Bloquea el subproceso actual hasta que la instancia actual recibe una señal; usa TimeSpan para determinar el intervalo de tiempo y especifica si hay que abandonar el dominio de sincronización antes de la 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)

Propiedades

Handle Handle Handle Handle

Obtiene o establece el identificador del sistema operativo nativo.Gets or sets the native operating system handle.

(Inherited from WaitHandle)
SafeWaitHandle SafeWaitHandle SafeWaitHandle SafeWaitHandle

Obtiene o establece el identificador del sistema operativo nativo.Gets or sets the native operating system handle.

(Inherited from WaitHandle)

Implementaciones de interfaz explícitas

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

Libera todos los recursos que usa WaitHandle.Releases all resources used by the WaitHandle.

(Inherited from WaitHandle)

Campos

WaitTimeout WaitTimeout WaitTimeout WaitTimeout

Indica que una operación WaitAny(WaitHandle[], Int32, Boolean) ha superado el tiempo de espera antes de que se señalara un identificador de espera.Indicates that a WaitAny(WaitHandle[], Int32, Boolean) operation timed out before any of the wait handles were signaled. Este campo es constante.This field is constant.

(Inherited from WaitHandle)

Extension Methods

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)

Obtiene el identificador seguro para un identificador de espera del sistema operativo nativo.Gets the safe handle for a native operating system wait handle.

SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle) SetSafeWaitHandle(WaitHandle, SafeWaitHandle)

Establece un controlador seguro para un identificador de espera del sistema operativo nativo.Sets a safe handle for a native operating system wait handle.

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.This type is thread safe.

Consulte también: