Mutex Clase

Definición

Espacio de nombres:

System.Threading

Ensamblado:

System.Threading.dll

Source:

Mutex.cs

Primitiva de sincronización que puede usarse también para la sincronización entre procesos.

public ref class Mutex sealed : System::Threading::WaitHandle

public sealed class Mutex : System.Threading.WaitHandle

type Mutex = class
    inherit WaitHandle

Public NotInheritable Class Mutex
Inherits WaitHandle

Herencia

Object

MarshalByRefObject

WaitHandle

Mutex

Ejemplos

En este ejemplo se muestra cómo se usa un objeto local Mutex para sincronizar el acceso a un recurso protegido. Dado que cada subproceso que realiza la llamada se bloquea hasta que adquiere la propiedad de la exclusión mutua, debe llamar al método para liberar la ReleaseMutex propiedad de la exclusión mutua.

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 al WaitOne(Int32) método para adquirir la exclusión mutua. Si transcurre el intervalo de tiempo de espera, el método devuelve falsey el subproceso no adquiere la exclusión mutua ni obtiene acceso al recurso que protege la exclusión mutua. El ReleaseMutex subproceso que adquiere la exclusión mutua solo llama al método .

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 necesitan acceder 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. Mutex es un primitivo de sincronización que concede acceso exclusivo al recurso compartido a un único subproceso. Si un subproceso adquiere una exclusión mutua, el segundo subproceso que quiere adquirir esa exclusión mutua se suspende hasta que el primer subproceso libera la exclusión mutua.

Importante

Este tipo implementa la interfaz IDisposable. Cuando haya terminado de utilizar el tipo, debe desecharlo directa o indirectamente. Para eliminar el tipo directamente, llame a su método Dispose en un bloque try/catch. Para deshacerse de él indirectamente, use una construcción de lenguaje como using (en C#) o Using (en Visual Basic). Para más información, vea la sección "Uso de objetos que implementan IDisposable" en el tema de la interfaz IDisposable.

Puede usar el WaitHandle.WaitOne método para solicitar la propiedad de una exclusión mutua. El subproceso que realiza la llamada se bloquea hasta que se produzca una de las siguientes acciones:

• La exclusión mutua se señala para indicar que no es propiedad. Cuando esto sucede, el WaitOne método devuelve truey el subproceso que realiza la llamada asume la propiedad de la exclusión mutua y accede al recurso protegido por la exclusión mutua. Cuando haya terminado de acceder al recurso, el subproceso debe llamar al método para liberar la ReleaseMutex propiedad de la exclusión mutua. En el primer ejemplo de la sección Ejemplos se muestra este patrón.

• Intervalo de tiempo de espera especificado en la llamada a un WaitOne método que tiene transcurrido un millisecondsTimeout parámetro o timeout . Cuando esto sucede, el WaitOne método devuelve falsey el subproceso que realiza la llamada no intenta adquirir aún más la propiedad de la exclusión mutua. En este caso, debe estructurar el código para que el acceso al recurso protegido por la exclusión mutua se deniegue al subproceso que realiza la llamada. Dado que el subproceso nunca adquirió la propiedad de la exclusión mutua, no debe llamar al ReleaseMutex método . En el segundo ejemplo de la sección Ejemplos se muestra este patrón.

La Mutex clase aplica la identidad del subproceso, por lo que solo el subproceso que lo adquirió puede liberar una exclusión mutua. Por el contrario, la clase no aplica la Semaphore identidad del subproceso. También se puede pasar una exclusión mutua a través de los límites del dominio de aplicación.

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. Sin embargo, el subproceso debe llamar al ReleaseMutex método el mismo número de veces para liberar la propiedad de la exclusión mutua.

Dado que la Mutex clase hereda de WaitHandle, también puede llamar a los métodos estáticos WaitHandle.WaitAll y WaitHandle.WaitAny para sincronizar el acceso a un recurso protegido.

Si un subproceso finaliza mientras posee una exclusión mutua, se dice que la exclusión mutua se abandona. El estado de la exclusión mutua se establece en señalado y el siguiente subproceso en espera obtiene la propiedad. A partir de la versión 2.0 de .NET Framework, se produce una AbandonedMutexException excepción en el siguiente subproceso que adquiere la exclusión mutua abandonada. Antes de la versión 2.0 de .NET Framework, no se produjo ninguna excepción.

Precaución

Una exclusión mutua abandonada suele indicar un error grave en el código. Cuando un subproceso sale sin liberar la exclusión mutua, es posible que las estructuras de datos protegidas por la exclusión mutua no estén en un estado coherente. El siguiente subproceso para solicitar 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.

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

Las exclusiones mutuas son de dos tipos: exclusiones mutuas locales, que no tienen nombre y exclusiones mutuas del sistema con nombre. Una exclusión mutua local solo existe dentro del proceso. Se puede usar en cualquier subproceso del proceso que tenga una referencia al Mutex objeto que representa la exclusión mutua. Cada objeto sin Mutex nombre representa una exclusión mutua local independiente.

Las exclusiones mutuas del sistema con nombre son visibles en todo el sistema operativo y se pueden usar para sincronizar las actividades de los procesos. Puede crear un Mutex objeto que represente una exclusión mutua del sistema con nombre mediante un constructor que acepte un nombre. El objeto del sistema operativo se puede crear al mismo tiempo o puede existir antes de crear el Mutex objeto. 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.

Nota:

En un servidor que ejecuta Terminal Services, una exclusión mutua del sistema con nombre puede tener dos niveles de visibilidad. Si su nombre comienza con el prefijo Global\, la exclusión mutua está visible en todas las sesiones de terminal Server. Si su nombre comienza con el prefijo Local\, la exclusión mutua solo es visible en la sesión del servidor de terminal donde se creó. 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 del servidor. Si no especifica un prefijo al crear una exclusión mutua con nombre, toma el prefijo Local\. Dentro de una sesión de terminal Server, dos exclusiones mutuas cuyos nombres solo difieren por sus prefijos son mutuas independientes y ambos son visibles para todos los procesos de la sesión del servidor de terminal. Es decir, los nombres Global\ de prefijo y Local\ describen el ámbito del nombre de exclusión mutua en relación con las sesiones de terminal server, no en relación con los procesos.

Precaución

De forma predeterminada, una exclusión mutua con nombre no está restringida al usuario que lo creó. Es posible que otros usuarios puedan abrir y usar la exclusión mutua, incluida la interferencia con la exclusión mutua escribiendo la exclusión mutua y no saliendo de ella. En sistemas operativos similares a Unix, el sistema de archivos se usa en la implementación de exclusiones mutuas con nombre y otros usuarios pueden interferir con exclusiones mutuas con nombre de maneras más significativas. En Windows, para restringir el acceso a usuarios específicos, puede usar una sobrecarga de constructor o MutexAcl pasar un MutexSecurity elemento al crear la exclusión mutua con nombre. En sistemas operativos similares a Unix, actualmente no hay ninguna manera de restringir el acceso a una exclusión mutua con nombre. Evite usar exclusiones mutuas con nombre sin restricciones de acceso en sistemas que puedan tener usuarios que no son de confianza que ejecuten código.

La barra diagonal inversa (\) es un carácter reservado en un nombre de exclusión mutua. 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. En caso contrario, es posible que se inicie una excepción DirectoryNotFoundException, aunque el nombre de la exclusión mutua represente un archivo existente.

Constructores

Mutex()	Inicializa una nueva instancia de la clase Mutex con propiedades predeterminadas.
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.
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.
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.

Campos

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. Este campo es constante. (Heredado de WaitHandle)

Propiedades

Handle	Obsoletos. Obtiene o establece el identificador del sistema operativo nativo. (Heredado de WaitHandle)
SafeWaitHandle	Obtiene o establece el identificador del sistema operativo nativo. (Heredado de WaitHandle)

Métodos

Close()	Libera todos los recursos mantenidos por el objeto WaitHandle actual. (Heredado de WaitHandle)
CreateObjRef(Type)	Crea un objeto que contiene toda la información relevante necesaria para generar un proxy utilizado para comunicarse con un objeto remoto. (Heredado de MarshalByRefObject)
Dispose()	Libera todos los recursos usados por la instancia actual de la clase WaitHandle. (Heredado de WaitHandle)
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. (Heredado de WaitHandle)
Equals(Object)	Determina si el objeto especificado es igual que el objeto actual. (Heredado de Object)
GetHashCode()	Sirve como la función hash predeterminada. (Heredado de Object)
GetLifetimeService()	Obsoletos. Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
GetType()	Obtiene el Type de la instancia actual. (Heredado de Object)
InitializeLifetimeService()	Obsoletos. Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia. (Heredado de MarshalByRefObject)
MemberwiseClone()	Crea una copia superficial del Object actual. (Heredado de Object)
MemberwiseClone(Boolean)	Crea una copia superficial del objeto MarshalByRefObject actual. (Heredado de MarshalByRefObject)
OpenExisting(String)	Abre la exclusión mutua con nombre especificada, si ya existe.
ReleaseMutex()	Libera una vez la instancia de Mutex.
ToString()	Devuelve una cadena que representa el objeto actual. (Heredado de Object)
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.
WaitOne()	Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal. (Heredado de WaitHandle)
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. (Heredado de WaitHandle)
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. (Heredado de WaitHandle)
WaitOne(TimeSpan)	Bloquea el subproceso actual hasta que la instancia actual recibe una señal, usando TimeSpan para especificar el intervalo de tiempo. (Heredado de WaitHandle)
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. (Heredado de WaitHandle)

Métodos de extensión

GetAccessControl(Mutex)	Devuelve los descriptores de seguridad para el objeto mutex especificado.
SetAccessControl(Mutex, MutexSecurity)	Establece los descriptores de seguridad para la exclusión mutua especificada.
GetSafeWaitHandle(WaitHandle)	Obtiene el controlador seguro para un identificador de espera del sistema operativo nativo.
SetSafeWaitHandle(WaitHandle, SafeWaitHandle)	Establece un controlador seguro para un identificador de espera del sistema operativo nativo.

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.

Consulte también

• WaitHandle
• Thread
• Subprocesamiento administrado
• Mutexes (Clases Mutex)