Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Clase Mutex

 

Publicado: octubre de 2016

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

Espacio de nombres:   System.Threading
Ensamblado:  mscorlib (en mscorlib.dll)

System.Object
  System.MarshalByRefObject
    System.Threading.WaitHandle
      System.Threading.Mutex

[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public sealed class Mutex : WaitHandle

NombreDescripción
System_CAPS_pubmethodMutex()

Inicializa una nueva instancia de la clase Mutex con propiedades predeterminadas.

System_CAPS_pubmethodMutex(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.

System_CAPS_pubmethodMutex(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.

System_CAPS_pubmethodMutex(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.

System_CAPS_pubmethodMutex(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.

NombreDescripción
System_CAPS_pubpropertyHandle

Obsoleto.Obtiene o establece el identificador del sistema operativo nativo.(Heredado de WaitHandle).

System_CAPS_pubpropertySafeWaitHandle

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

NombreDescripción
System_CAPS_pubmethodClose()

Libera todos los recursos mantenidos por el objeto WaitHandle actual.(Heredado de WaitHandle).

System_CAPS_pubmethodCreateObjRef(Type)

Crea un objeto que contiene toda la información pertinente necesaria para generar a un proxy utilizado para comunicarse con un objeto remoto.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodDispose()

Libera todos los recursos usados por la instancia actual de la clase WaitHandle.(Heredado de WaitHandle).

System_CAPS_pubmethodEquals(Object)

Determina si el objeto especificado es igual al objeto actual.(Heredado de Object).

System_CAPS_pubmethodGetAccessControl()

Obtiene un objeto MutexSecurity que representa la seguridad de control de acceso para la exclusión mutua con nombre.

System_CAPS_pubmethodGetHashCode()

Sirve como la función hash predeterminada.(Heredado de Object).

System_CAPS_pubmethodGetLifetimeService()

Recupera el objeto de servicio de duración actual que controla la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodGetType()

Obtiene el Type de la instancia actual.(Heredado de Object).

System_CAPS_pubmethodInitializeLifetimeService()

Obtiene un objeto de servicio de duración para controlar la directiva de duración de esta instancia.(Heredado de MarshalByRefObject).

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String)

Abre la exclusión mutua con nombre especificada, si ya existe.

System_CAPS_pubmethodSystem_CAPS_staticOpenExisting(String, MutexRights)

Abre la exclusión mutua con nombre especificada, si ya existe, con el acceso de seguridad deseado.

System_CAPS_pubmethodReleaseMutex()

Libera una vez la instancia de Mutex.

System_CAPS_pubmethodSetAccessControl(MutexSecurity)

Establece la seguridad de control de acceso para una exclusión mutua del sistema con nombre.

System_CAPS_pubmethodToString()

Devuelve una cadena que representa al objeto actual. (Heredado de Object).

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(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.

System_CAPS_pubmethodSystem_CAPS_staticTryOpenExisting(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.

System_CAPS_pubmethodWaitOne()

Bloquea el subproceso actual hasta que el objeto WaitHandle actual recibe una señal.(Heredado de WaitHandle).

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

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

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

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

NombreDescripción
System_CAPS_pubmethodGetSafeWaitHandle()

Obtiene el identificador seguro para un identificador de espera del sistema operativo nativo.(Definido por WaitHandleExtensions).

System_CAPS_pubmethodSetSafeWaitHandle(SafeWaitHandle)

Establece un controlador seguro para un identificador de espera del sistema operativo nativo.(Definido por WaitHandleExtensions).

System_CAPS_noteNota

Para ver el código fuente de .NET Framework para este tipo, consulte el Reference Source. Puede examinar el código fuente en línea, descargue la referencia para verla sin conexión y recorrer (incluidas las revisiones y actualizaciones) durante la depuración; see instructions.

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 garantizar que sólo un subproceso a la vez utilice el recurso. Mutex es una sincronización primitivos que otorga acceso exclusivo al recurso compartido a un solo subproceso. Si un subproceso adquiere una exclusión mutua, el segundo subproceso que intenta adquirir dicha exclusión mutua se suspende hasta que el primer subproceso libera la exclusión mutua.

System_CAPS_importantImportante

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

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

  • La exclusión mutua se señala para indicar que no pertenece. Cuando esto sucede, el WaitOne método devuelve true, y el subproceso de llamada asume la propiedad de la exclusión mutua y tiene acceso al recurso protegido por la exclusión mutua. Cuando termine de obtener acceso al recurso, el subproceso debe llamar a la ReleaseMutex método para liberar la propiedad de la exclusión mutua. El primer ejemplo de la sección de ejemplos muestra este modelo.

  • 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. Cuando esto sucede, el WaitOne método devuelve false, y no hace que el subproceso de llamada volverá a intentar adquirir la propiedad de la exclusión mutua. 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. Dado que el subproceso nunca haya adquirido la propiedad del mutex, no debe llamar el ReleaseMutex método. El segundo ejemplo de la sección de ejemplos muestra este modelo.

La Mutex clase exige la identidad del subproceso, por lo que una exclusión mutua se puede liberar el subproceso que lo adquirió. Por el contrario, la Semaphore clase no exige la identidad del subproceso. Una exclusión mutua también se puede pasar 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 a la ReleaseMutex el mismo número de veces para liberar la propiedad de la exclusión mutua del método.

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

Si un subproceso finaliza mientras posee una exclusión mutua, se dice la exclusión mutua abandonada. 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, un AbandonedMutexException se produce en el subproceso siguiente que adquiere la exclusión mutua abandonada. Antes de la versión 2.0 de .NET Framework, se inicia ninguna excepción.

System_CAPS_cautionPrecaución

A menudo, un mutex abandonado indica un error grave en el código. Cuando un subproceso sale sin liberar el mutex, las estructuras de datos protegidas por el mutex no estén en un estado coherente. 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.

En el caso de una exclusión mutua todo el sistema, un mutex abandonado podría indicar que una aplicación ha finalizado inesperadamente (por ejemplo, mediante el Administrador de tareas de Windows).

Las exclusiones mutuas son de dos tipos: exclusiones mutuas locales, sin nombre, y exclusiones mutuas del sistema con el nombre. Una exclusión mutua local sólo existe dentro del proceso. Se puede usar cualquier subproceso del proceso que tiene una referencia a la Mutex objeto que representa la exclusión mutua. Cada uno sin nombre Mutex objeto representa una exclusión mutua local independiente.

Las exclusiones mutuas son visibles en todo el sistema operativo y pueden utilizarse para sincronizar las actividades de procesos de sistema con nombre. Puede crear un Mutex objeto que representa una exclusión mutua del sistema con nombre utilizando un constructor que acepta un nombre. Se puede crear el objeto de sistema operativo al mismo tiempo o puede existir antes de la creación de la Mutex objeto. Puede crear varias Mutex objetos que representan el mismo nombre exclusión mutua del sistema y puede utilizar el OpenExisting método para abrir una existente denominado exclusión mutua del sistema.

System_CAPS_noteNota

En un servidor que ejecuta Servicios de Terminal Server, una exclusión mutua del sistema con nombre puede tener dos niveles de visibilidad. Si su nombre empieza con el prefijo "Global\", la exclusión mutua es visible en todas las sesiones de terminal server. Si su nombre empieza con el prefijo "Local\", la exclusión mutua sólo es visible en la sesión de terminal server 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 en el servidor. Si no especifica ningún 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 se diferencien sólo por sus prefijos son exclusiones mutuas independientes y ambos son visibles para todos los procesos en la sesión de terminal server. Es decir, los nombres de prefijo "Global\" y "Local\" describen el ámbito del nombre de exclusión mutua con respecto a las sesiones de terminal server, no en relación con los procesos.

Este ejemplo muestra cómo una variable local Mutex objeto se utiliza para sincronizar el acceso a un recurso protegido. 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.

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

En el ejemplo siguiente, cada subproceso llama el WaitOne(Int32) método adquirir la exclusión mutua. 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. El ReleaseMutex se invoca el subproceso que adquiere 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()
    {
        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

Plataforma universal de Windows
Disponible desde 8
.NET Framework
Disponible desde 1.1
Biblioteca de clases portable
Se admite en: plataformas portátiles de .NET
Windows Phone Silverlight
Disponible desde 7.1
Windows Phone
Disponible desde 8.1

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

Volver al principio
Mostrar: