Exportar (0) Imprimir
Expandir todo

Mutex (Clase)

Actualización: noviembre 2007

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

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

[ComVisibleAttribute(true)]
[HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, 
	ExternalThreading = true)]
public sealed class Mutex : WaitHandle
/** @attribute ComVisibleAttribute(true) */
/** @attribute HostProtectionAttribute(SecurityAction.LinkDemand, Synchronization = true, ExternalThreading = true) */
public final class Mutex extends WaitHandle
public final class Mutex extends WaitHandle

01985e8f.alert_note(es-es,VS.90).gifNota:

El atributo HostProtectionAttribute aplicado a este tipo o miembro tiene el siguiente valor de la propiedad Resources: Synchronization | ExternalThreading. El atributo HostProtectionAttribute no afecta a las aplicaciones de escritorio (que normalmente se inician haciendo doble clic en un icono, escribiendo un comando o introduciendo una dirección URL en el explorador). Para obtener más información, vea la clase HostProtectionAttribute o Programación de SQL Server y atributos de protección del host.

Cuando dos o más subprocesos tienen que obtener acceso a un recurso compartido al mismo tiempo, el sistema necesita un mecanismo de sincronización para garantizar que sólo uno de los subprocesos utilice el recurso en ese momento. Mutex es un primitivo de sincronización que otorga acceso exclusivo al recurso compartido a un solo subproceso. Cuando un subproceso adquiere una exclusión mutua (mutex), el siguiente subproceso que intenta adquirir dicha exclusión mutua se suspende hasta que el primer subproceso libera la exclusión mutua.

Para solicitar la propiedad de una exclusión mutua puede utilizar el método WaitHandle.WaitOne. 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 método ReleaseMutex el mismo número de veces para liberar la propiedad de la exclusión mutua. La clase Mutex exige la identidad del subproceso, por lo que sólo podrá liberar la exclusión mutua el subproceso que la adquirió. Por el contrario, la clase Semaphore no exige la identidad del subproceso.

Si un subproceso finaliza mientras posee una exclusión mutua, se dice que la exclusión mutua está abandonada. El estado de la exclusión mutua se establece en señalado y el siguiente subproceso en espera pasa a ser su propietario. A partir de la versión 2.0 de .NET Framework, se inicia AbandonedMutexException en el siguiente subproceso que adquiere la exclusión mutua abandonada. En las versiones de .NET Framework anteriores a la 2.0, no se producía ninguna excepción.

01985e8f.alert_caution(es-es,VS.90).gifPrecaució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, el estado de las estructuras de datos a las que protege la exclusión mutua podría ser inconstante. 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 exclusión mutua en todo el sistema, una exclusión mutua podría indicar que una aplicación ha finalizado de forma abrupta (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 nombre. Una exclusión mutua local sólo existe dentro del proceso del usuario. La puede usar cualquier subproceso del proceso que contenga una referencia al objeto Mutex que la representa. Cada objeto Mutex sin 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 utilizar para sincronizar las actividades de los procesos. Puede crear un objeto Mutex que representa una exclusión mutua del sistema con nombre mediante el uso de un constructor que acepte un nombre. Se puede crear el objeto de sistema operativo al mismo tiempo o puede existir antes de la creación del objeto Mutex. Puede crear varios objetos Mutex que representen la misma exclusión mutua del sistema con nombre y puede utilizar el método OpenExisting para abrir una exclusión mutua del sistema con nombre ya existente.

01985e8f.alert_note(es-es,VS.90).gifNota:

En un servidor en el que se ejecuta Terminal Services, una exclusión mutua del sistema con nombre puede tener dos niveles de visibilidad. Si su nombre empieza por el prefijo "Global\", la exclusión mutua se ve en todas las sesiones de Terminal Server. Si su nombre empieza por el prefijo "Local\", la exclusión mutua se ve sólo en la sesión de Terminal Server en la que se creó. En ese caso, puede existir una exclusión mutua independiente con el mismo nombre en todas las sesiones de Terminal Server del servidor. Si no especifica ningún prefijo al crear una exclusión mutua con nombre, toma el prefijo "Local\". En una sesión de Terminal Server, dos exclusiones mutuas cuyos nombres se diferencian sólo por sus prefijos son exclusiones mutuas independientes y las ven todos los procesos de la sesión de Terminal Server. Es decir, los nombres de prefijo "Global\" y "Local\" describen el ámbito del nombre de la exclusión mutua respecto a las sesiones de Terminal Server, y no respecto a los procesos.

En este ejemplo se muestra cómo utilizar un objeto Mutex local para sincronizar el acceso a un recurso protegido.

// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.

using System;
using System.Threading;

class Test
{
    // 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 myThread = new Thread(new ThreadStart(MyThreadProc));
            myThread.Name = String.Format("Thread{0}", i + 1);
            myThread.Start();
        }

        // The main thread exits, but the application continues to
        // run until all foreground threads have exited.
    }

    private static void MyThreadProc()
    {
        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.
        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\r\n", 
            Thread.CurrentThread.Name);

        // Release the Mutex.
        mut.ReleaseMutex();
    }
}


// This example shows how a Mutex is used to synchronize access
// to a protected resource. Unlike Monitor, Mutex can be used with
// WaitHandle.WaitAll and WaitAny, and can be passed across
// AppDomain boundaries.

import System.*;
import System.Threading.*;
import System.Threading.Thread;

class Test
{
    // Create a new Mutex. The creating thread does not own the
    // Mutex.
    private static Mutex mut = new Mutex();
    private static int numIterations = 1;
    private static int numThreads = 3;

    public static void main(String[] args)
    {
        // Create the threads that will use the protected resource.
        for (int i = 0; i < numThreads; i++) {
            Thread myThread = new Thread(new ThreadStart(MyThreadProc));
            myThread.set_Name(String.Format("Thread{0}", 
                String.valueOf(i + 1)));
            myThread.Start();
        }
    } //main

    // The main thread exits, but the application continues to
    // run until all foreground threads have exited.
    private static void MyThreadProc()
    {
        for (int i = 0; i < numIterations; i++) {
            UseResource();
        }
    } //MyThreadProc

    // 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.
        mut.WaitOne();
        Console.WriteLine("{0} has entered the protected area", 
            Thread.get_CurrentThread().get_Name());

        // Place code to access non-reentrant resources here.
        // Simulate some work.
        Thread.Sleep(500);
        Console.WriteLine("{0} is leaving the protected area\r\n", 
            Thread.get_CurrentThread().get_Name());

        // Release the Mutex.
        mut.ReleaseMutex();
    } //UseResource
} //Test


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

Windows Vista, Windows XP SP2, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP Starter Edition, Windows Server 2003, Windows Server 2000 SP4, Windows Millennium Edition, Windows 98, Windows CE, Windows Mobile para Smartphone, Windows Mobile para Pocket PC, Xbox 360

.NET Framework y .NET Compact Framework no admiten todas las versiones de cada plataforma. Para obtener una lista de las versiones compatibles, vea Requisitos de sistema de .NET Framework.

.NET Framework

Compatible con: 3.5, 3.0, 2.0, 1.1, 1.0

.NET Compact Framework

Compatible con: 3.5, 2.0, 1.0

XNA Framework

Compatible con: 2.0, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft