Mutex Clase

Definición

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

public sealed class Mutex : System.Threading.WaitHandle

[System.Runtime.InteropServices.ComVisible(true)]
public sealed class Mutex : System.Threading.WaitHandle

type Mutex = class
    inherit WaitHandle

[<System.Runtime.InteropServices.ComVisible(true)>]
type Mutex = class
    inherit WaitHandle

Public NotInheritable Class Mutex
Inherits WaitHandle

Herencia

Object

WaitHandle

Mutex

Herencia

Object

MarshalByRefObject

WaitHandle

Mutex

Atributos

ComVisibleAttribute

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.

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.

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.

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

Campos

Propiedades

Métodos

Implementaciones de interfaz explícitas

Métodos de extensión

Se aplica a

Seguridad para subprocesos

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

Consulte también

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