Compartir a través de


Mutex Constructores

Definición

Inicializa una nueva instancia de la clase Mutex.

Sobrecargas

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.

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.

Mutex()

Source:
Mutex.cs
Source:
Mutex.cs
Source:
Mutex.cs

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

public:
 Mutex();
public Mutex ();
Public Sub New ()

Ejemplos

En el ejemplo de código siguiente se muestra cómo se usa un objeto local Mutex para sincronizar el acceso a un recurso protegido. El subproceso que crea la exclusión mutua no lo posee inicialmente.

// 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 namespace System;
using namespace System::Threading;
const int numIterations = 1;
const int numThreads = 3;
ref class Test
{
public:

   // Create a new Mutex. The creating thread does not own the
   // Mutex.
   static Mutex^ mut = gcnew Mutex;
   static void MyThreadProc()
   {
      for ( int i = 0; i < numIterations; i++ )
      {
         UseResource();

      }
   }


private:

   // This method represents a resource that must be synchronized
   // so that only one thread at a time can enter.
   static void UseResource()
   {
      
      //Wait until it is OK to enter.
      mut->WaitOne();
      Console::WriteLine( "{0} has entered protected the area", Thread::CurrentThread->Name );
      
      // Place code to access non-reentrant resources here.
      // Simulate some work.
      Thread::Sleep( 500 );
      Console::WriteLine( "{0} is leaving protected the area\r\n", Thread::CurrentThread->Name );
      
      // Release the Mutex.
      mut->ReleaseMutex();
   }

};

int main()
{
   
   // Create the threads that will use the protected resource.
   for ( int i = 0; i < numThreads; i++ )
   {
      Thread^ myThread = gcnew Thread( gcnew ThreadStart( Test::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.
}
// 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 Test13
{
    // 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.
 
Imports System.Threading

Class Test
    ' Create a new Mutex. The creating thread does not own the
    ' Mutex.
    Private Shared mut As New Mutex()
    Private Const numIterations As Integer = 1
    Private Const numThreads As Integer = 3

    <MTAThread> _
    Shared Sub Main()
        ' Create the threads that will use the protected resource.
        Dim i As Integer
        For i = 1 To numThreads
            Dim myThread As New Thread(AddressOf MyThreadProc)
            myThread.Name = [String].Format("Thread{0}", i)
            myThread.Start()
        Next i

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

    End Sub

    Private Shared Sub MyThreadProc()
        Dim i As Integer
        For i = 1 To numIterations
            UseResource()
        Next i
    End Sub

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Shared Sub UseResource()
        ' Wait until it is safe to enter.
        mut.WaitOne()

        Console.WriteLine("{0} has entered protected area", _
            Thread.CurrentThread.Name)

        ' Place code to access non-reentrant resources here.

        ' Simulate some work
        Thread.Sleep(500)

        Console.WriteLine("{0} is leaving protected area" & vbCrLf, _
            Thread.CurrentThread.Name)

        ' Release Mutex.
        mut.ReleaseMutex()
    End Sub
End Class

Comentarios

Llamar a esta sobrecarga de constructor es la misma que llamar a la sobrecarga del Mutex(Boolean) constructor y especificar false para la propiedad inicial de la exclusión mutua. Es decir, el subproceso que realiza la llamada no posee la exclusión mutua.

Consulte también

Se aplica a

Mutex(Boolean)

Source:
Mutex.cs
Source:
Mutex.cs
Source:
Mutex.cs

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.

public:
 Mutex(bool initiallyOwned);
public Mutex (bool initiallyOwned);
new System.Threading.Mutex : bool -> System.Threading.Mutex
Public Sub New (initiallyOwned As Boolean)

Parámetros

initiallyOwned
Boolean

true para otorgar la propiedad inicial de la exclusión mutua al subproceso que realiza la llamada, en caso contrario, false.

Ejemplos

En el ejemplo de código siguiente se muestra cómo se usa un objeto local Mutex para sincronizar el acceso a un recurso protegido. El subproceso que crea el Mutex propietario inicialmente.

using namespace System;
using namespace System::Threading;

const int numIterations = 1;
const int numThreads = 3;

ref class Test
{
public:

   // Create a new Mutex. The creating thread owns the
   // Mutex.
   static Mutex^ mut = gcnew Mutex( true );
   static void MyThreadProc()
   {
      for ( int i = 0; i < numIterations; i++ )
      {
         UseResource();

      }
   }


private:

   // This method represents a resource that must be synchronized
   // so that only one thread at a time can enter.
   static void UseResource()
   {
      
      //Wait until it is OK to enter.
      mut->WaitOne();
      Console::WriteLine( "{0} has entered protected the area", Thread::CurrentThread->Name );
      
      // Place code to access non-reentrant resources here.
      // Simulate some work.
      Thread::Sleep( 500 );
      Console::WriteLine( "{0} is leaving protected the area\r\n", Thread::CurrentThread->Name );
      
      // Release the Mutex.
      mut->ReleaseMutex();
   }

};

int main()
{
   
   // Initialize the Mutex.
   Mutex^ mut = Test::mut;
   
   // Create the threads that will use the protected resource.
   for ( int i = 0; i < numThreads; i++ )
   {
      Thread^ myThread = gcnew Thread( gcnew ThreadStart( Test::MyThreadProc ) );
      myThread->Name = String::Format( "Thread {0}", i + 1 );
      myThread->Start();

   }
   
   // Wait one second before allowing other threads to
   // acquire the Mutex.
   Console::WriteLine( "Creating thread owns the Mutex." );
   Thread::Sleep( 1000 );
   Console::WriteLine( "Creating thread releases the Mutex.\r\n" );
   mut->ReleaseMutex();
}
// The example displays output like the following:
//       Creating thread owns the Mutex.
//       Creating thread releases the Mutex.
//       
//       Thread1 has entered the protected area
//       Thread1 is leaving the protected area
//       
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
using System;
using System.Threading;

class Test
{
    private static Mutex mut;
    private const int numIterations = 1;
    private const int numThreads = 3;

    static void Main()
    {
        // Create a new Mutex. The creating thread owns the Mutex.
        mut = new Mutex(true);
        // 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();
        }

        // Wait one second before allowing other threads to
        // acquire the Mutex.
        Console.WriteLine("Creating thread owns the Mutex.");
        Thread.Sleep(1000);

        Console.WriteLine("Creating thread releases the Mutex.\r\n");
        mut.ReleaseMutex();
    }

    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();
    }
}
// The example displays output like the following:
//       Creating thread owns the Mutex.
//       Creating thread releases the Mutex.
//       
//       Thread1 has entered the protected area
//       Thread1 is leaving the protected area
//       
//       Thread2 has entered the protected area
//       Thread2 is leaving the protected area
//       
//       Thread3 has entered the protected area
//       Thread3 is leaving the protected area
Imports System.Threading

Class Test
    ' Create a new Mutex. The creating thread owns the
    ' Mutex.
    Private Shared mut As New Mutex(True)
    Private Const numIterations As Integer = 1
    Private Const numThreads As Integer = 3

    <MTAThread> _
    Shared Sub Main()
        ' Create the threads that will use the protected resource.
        Dim i As Integer
        For i = 1 To numThreads
            Dim myThread As New Thread(AddressOf MyThreadProc)
            myThread.Name = [String].Format("Thread{0}", i)
            myThread.Start()
        Next i

        ' Wait one second before allowing other threads to
        ' acquire the Mutex.
        Console.WriteLine("Creating thread owns the Mutex.")
        Thread.Sleep(1000)

        Console.WriteLine("Creating thread releases the Mutex." & vbCrLf)
        mut.ReleaseMutex()
    End Sub

    Private Shared Sub MyThreadProc()
        Dim i As Integer
        For i = 1 To numIterations
            UseResource()
        Next i
    End Sub

    ' This method represents a resource that must be synchronized
    ' so that only one thread at a time can enter.
    Private Shared Sub UseResource()
        ' Wait until it is safe to enter.
        mut.WaitOne()

        Console.WriteLine("{0} has entered protected area", _
            Thread.CurrentThread.Name)

        ' Place code to access non-reentrant resources here.

        ' Simulate some work
        Thread.Sleep(500)

        Console.WriteLine("{0} is leaving protected area" & vbCrLf, _
            Thread.CurrentThread.Name)

        ' Release Mutex.
        mut.ReleaseMutex()
    End Sub
End Class
' The example displays output like the following:
'       Creating thread owns the Mutex.
'       Creating thread releases the Mutex.
'       
'       Thread1 has entered the protected area
'       Thread1 is leaving the protected area
'       
'       Thread2 has entered the protected area
'       Thread2 is leaving the protected area
'       
'       Thread3 has entered the protected area
'       Thread3 is leaving the protected area

Consulte también

Se aplica a

Mutex(Boolean, String)

Source:
Mutex.cs
Source:
Mutex.cs
Source:
Mutex.cs

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.

public:
 Mutex(bool initiallyOwned, System::String ^ name);
[System.Security.SecurityCritical]
public Mutex (bool initiallyOwned, string name);
public Mutex (bool initiallyOwned, string? name);
public Mutex (bool initiallyOwned, string name);
[<System.Security.SecurityCritical>]
new System.Threading.Mutex : bool * string -> System.Threading.Mutex
new System.Threading.Mutex : bool * string -> System.Threading.Mutex
Public Sub New (initiallyOwned As Boolean, name As String)

Parámetros

initiallyOwned
Boolean

true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false.

name
String

Nombre, si el objeto de sincronización se va a compartir con otros procesos; en caso contrario, null o una cadena vacía. El nombre distingue entre mayúsculas y minúsculas. El carácter de barra diagonal inversa (\) está reservado y solo se puede usar para especificar un espacio de nombres. Para obtener más información sobre los espacios de nombres, consulte la sección comentarios. Puede haber más restricciones en el nombre en función del sistema operativo. Por ejemplo, en los sistemas operativos basados en Unix, el nombre después de excluir el espacio de nombres debe ser un nombre de archivo válido.

Atributos

Excepciones

La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene FullControl.

name no es válido. Esto puede deberse a diversos motivos, incluidas algunas restricciones que puede imponer el sistema operativo, como un prefijo desconocido o caracteres no válidos. Tenga en cuenta que el nombre y los prefijos comunes "Global\" y "Local\" distinguen mayúsculas de minúsculas.

O bien

Hubo algún otro error. La propiedad HResult puede proporcionar más información.

Solo Windows: name especificó un espacio de nombres desconocido. Consulte Nombres de objetos para obtener más información.

name es demasiado largo. Las restricciones de longitud pueden depender del sistema operativo o la configuración.

No se puede crear un objeto de sincronización con el valor name proporcionado. Un objeto de sincronización de un tipo diferente podría tener el mismo nombre.

Solo .NET Framework: name es mayor que MAX_PATH (260 caracteres).

Ejemplos

En el ejemplo siguiente se muestra cómo se usa una exclusión mutua con nombre para indicar entre subprocesos que se ejecutan en dos procesos independientes.

Ejecute este programa desde dos o más ventanas de comandos. Cada proceso crea un Mutex objeto que representa la exclusión mutua MyMutexcon nombre . La exclusión mutua con nombre es un objeto del sistema cuya duración está limitada por las duraciones de los Mutex objetos que lo representan. La exclusión mutua con nombre se crea cuando el primer proceso crea su Mutex objeto; en este ejemplo, la exclusión mutua con nombre es propiedad del primer proceso que ejecuta el programa. La exclusión mutua con nombre se destruye cuando se han liberado todos los Mutex objetos que lo representan.

La sobrecarga del constructor usada en este ejemplo no puede indicar al subproceso que llama si se concedió la propiedad inicial de la exclusión mutua con nombre. No debe usar este constructor para solicitar la propiedad inicial a menos que pueda estar seguro de que el subproceso creará la exclusión mutua con nombre.

using namespace System;
using namespace System::Threading;

int main()
{
   // Create the named mutex. Only one system object named 
   // "MyMutex" can exist; the local Mutex object represents 
   // this system object, regardless of which process or thread
   // caused "MyMutex" to be created.
   Mutex^ m = gcnew Mutex( false,"MyMutex" );
   
   // Try to gain control of the named mutex. If the mutex is 
   // controlled by another thread, wait for it to be released.        
   Console::WriteLine(  "Waiting for the Mutex." );
   m->WaitOne();
   
   // Keep control of the mutex until the user presses
   // ENTER.
   Console::WriteLine( "This application owns the mutex. "
   "Press ENTER to release the mutex and exit." );
   Console::ReadLine();
   m->ReleaseMutex();
}
using System;
using System.Threading;

public class Test1
{
    public static void Main()
    {
        // Create the named mutex. Only one system object named 
        // "MyMutex" can exist; the local Mutex object represents 
        // this system object, regardless of which process or thread
        // caused "MyMutex" to be created.
        Mutex m = new Mutex(false, "MyMutex");
        
        // Try to gain control of the named mutex. If the mutex is 
        // controlled by another thread, wait for it to be released.        
        Console.WriteLine("Waiting for the Mutex.");
        m.WaitOne();

        // Keep control of the mutex until the user presses
        // ENTER.
        Console.WriteLine("This application owns the mutex. " +
            "Press ENTER to release the mutex and exit.");
        Console.ReadLine();

        m.ReleaseMutex();
    }
}
Imports System.Threading

Public Class Test
   Public Shared Sub Main()
      ' Create the named mutex. Only one system object named 
      ' "MyMutex" can exist; the local Mutex object represents 
      ' this system object, regardless of which process or thread
      ' caused "MyMutex" to be created.
      Dim m As New Mutex(False, "MyMutex")
      
      ' Try to gain control of the named mutex. If the mutex is 
      ' controlled by another thread, wait for it to be released.        
      Console.WriteLine("Waiting for the Mutex.")
      m.WaitOne()
      
      ' Keep control of the mutex until the user presses
      ' ENTER.
      Console.WriteLine("This application owns the mutex. " _
          & "Press ENTER to release the mutex and exit.")
      Console.ReadLine()
      
      m.ReleaseMutex()
   End Sub 
End Class

Comentarios

name puede tener el prefijo o Global\Local\ especificar un espacio de nombres. Cuando se especifica el Global espacio de nombres, el objeto de sincronización se puede compartir con cualquier proceso del sistema. Cuando se especifica el Local espacio de nombres , que también es el valor predeterminado cuando no se especifica ningún espacio de nombres, el objeto de sincronización se puede compartir con procesos en la misma sesión. En Windows, una sesión es una sesión de inicio de sesión y los servicios normalmente se ejecutan en una sesión no interactiva diferente. En sistemas operativos similares a Unix, cada shell tiene su propia sesión. Los objetos de sincronización local de sesión pueden ser adecuados para sincronizar entre procesos con una relación primaria o secundaria en la que se ejecutan en la misma sesión. Para obtener más información sobre los nombres de objetos de sincronización en Windows, vea Nombres de objeto.

Si se proporciona y name ya existe un objeto de sincronización del tipo solicitado en el espacio de nombres, se usa el objeto de sincronización existente. Si ya existe un objeto de sincronización de un tipo diferente en el espacio de nombres , se produce una WaitHandleCannotBeOpenedException excepción . De lo contrario, se crea un nuevo objeto de sincronización.

Si name no null es y initiallyOwned es true, el subproceso que realiza la llamada posee la exclusión mutua solo si se creó la exclusión mutua del sistema con nombre como resultado de esta llamada. Puesto que no hay ningún mecanismo para determinar si se creó la exclusión mutua del sistema con nombre, es mejor especificar false para initiallyOwned al llamar a esta sobrecarga del constructor. Puede usar el constructor si necesita determinar la Mutex(Boolean, String, Boolean) propiedad inicial.

Este constructor inicializa un Mutex objeto que representa una exclusión mutua del sistema con nombre. Puede crear varios Mutex objetos que representen la misma exclusión mutua del sistema con nombre.

Si la exclusión mutua con nombre ya se ha creado con seguridad de control de acceso y el autor de la llamada no tiene MutexRights.FullControl, se produce una excepción. Para abrir una exclusión mutua con nombre existente solo con los permisos necesarios para sincronizar las actividades de subproceso, consulte el OpenExisting método .

Si especifica null o una cadena vacía para name, se crea una exclusión mutua local, como si hubiera llamado al Mutex(Boolean) constructor . En este caso, createdNew siempre truees .

Dado que son de todo el sistema, las exclusión mutuas con nombre se pueden usar para coordinar el uso de recursos a través de los límites del proceso.

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 es 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 exclusión mutua cuyos nombres solo difieren por sus prefijos son exclusiones 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 sin salir 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 las exclusión 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 el uso de exclusión mutua con nombre sin restricciones de acceso en sistemas que podrían tener usuarios que no son de confianza que ejecutan 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 según se especifica en la nota sobre el uso de exclusión mutua 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.

Consulte también

Se aplica a

Mutex(Boolean, String, Boolean)

Source:
Mutex.cs
Source:
Mutex.cs
Source:
Mutex.cs

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.

public:
 Mutex(bool initiallyOwned, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew);
[System.Security.SecurityCritical]
public Mutex (bool initiallyOwned, string name, out bool createdNew);
public Mutex (bool initiallyOwned, string? name, out bool createdNew);
public Mutex (bool initiallyOwned, string name, out bool createdNew);
[<System.Security.SecurityCritical>]
new System.Threading.Mutex : bool * string * bool -> System.Threading.Mutex
new System.Threading.Mutex : bool * string * bool -> System.Threading.Mutex
Public Sub New (initiallyOwned As Boolean, name As String, ByRef createdNew As Boolean)

Parámetros

initiallyOwned
Boolean

true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false.

name
String

Nombre, si el objeto de sincronización se va a compartir con otros procesos; en caso contrario, null o una cadena vacía. El nombre distingue entre mayúsculas y minúsculas. El carácter de barra diagonal inversa (\) está reservado y solo se puede usar para especificar un espacio de nombres. Para obtener más información sobre los espacios de nombres, consulte la sección comentarios. Puede haber más restricciones en el nombre en función del sistema operativo. Por ejemplo, en los sistemas operativos basados en Unix, el nombre después de excluir el espacio de nombres debe ser un nombre de archivo válido.

createdNew
Boolean

Cuando se devuelve este método, contiene un valor booleano que es true si se creó una exclusión mutua local (es decir, si name es null o una cadena vacía) o si se creó la exclusión mutua del sistema con nombre especificada; el valor es false si la exclusión mutua del sistema con nombre especificada ya existía. Este parámetro se pasa sin inicializar.

Atributos

Excepciones

La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene FullControl.

name no es válido. Esto puede deberse a diversos motivos, incluidas algunas restricciones que puede imponer el sistema operativo, como un prefijo desconocido o caracteres no válidos. Tenga en cuenta que el nombre y los prefijos comunes "Global\" y "Local\" distinguen mayúsculas de minúsculas.

O bien

Hubo algún otro error. La propiedad HResult puede proporcionar más información.

Solo Windows: name especificó un espacio de nombres desconocido. Consulte Nombres de objetos para obtener más información.

name es demasiado largo. Las restricciones de longitud pueden depender del sistema operativo o la configuración.

No se puede crear un objeto de sincronización con el valor name proporcionado. Un objeto de sincronización de un tipo diferente podría tener el mismo nombre.

Solo .NET Framework: name es mayor que MAX_PATH (260 caracteres).

Ejemplos

En el ejemplo de código siguiente se muestra cómo se usa una exclusión mutua con nombre para indicar entre procesos o subprocesos. Ejecute este programa desde dos o más ventanas de comandos. Cada proceso crea un Mutex objeto que representa la exclusión mutua con nombre "MyMutex". La exclusión mutua con nombre es un objeto del sistema. En este ejemplo, su duración está limitada por las duraciones de los Mutex objetos que lo representan. La exclusión mutua con nombre se crea cuando el primer proceso crea su objeto local Mutex y se destruye cuando se han liberado todos los Mutex objetos que lo representan. Inicialmente, la exclusión mutua con nombre es propiedad del primer proceso. El segundo proceso y los procesos posteriores esperan a que los procesos anteriores liberen la exclusión mutua con nombre.

// This example shows how a named mutex is used to signal between
// processes or threads.
// Run this program from two (or more) command windows. Each process
// creates a Mutex object that represents the named mutex "MyMutex".
// The named mutex is a system object whose lifetime is bounded by the
// lifetimes of the Mutex objects that represent it. The named mutex
// is created when the first process creates its local Mutex; in this
// example, the named mutex is owned by the first process. The named 
// mutex is destroyed when all the Mutex objects that represent it
// have been released. 
// The second process (and any subsequent process) waits for earlier
// processes to release the named mutex.
using namespace System;
using namespace System::Threading;
int main()
{
   
   // Set this variable to false if you do not want to request 
   // initial ownership of the named mutex.
   bool requestInitialOwnership = true;
   bool mutexWasCreated;
   
   // Request initial ownership of the named mutex by passing
   // true for the first parameter. Only one system object named 
   // "MyMutex" can exist; the local Mutex object represents 
   // this system object. If "MyMutex" is created by this call,
   // then mutexWasCreated contains true; otherwise, it contains
   // false.
   Mutex^ m = gcnew Mutex( requestInitialOwnership, "MyMutex", mutexWasCreated );
   
   // This thread owns the mutex only if it both requested 
   // initial ownership and created the named mutex. Otherwise,
   // it can request the named mutex by calling WaitOne.
   if (  !(requestInitialOwnership && mutexWasCreated) )
   {
      Console::WriteLine(  "Waiting for the named mutex." );
      m->WaitOne();
   }

   
   // Once the process has gained control of the named mutex,
   // hold onto it until the user presses ENTER.
   Console::WriteLine(  "This process owns the named mutex. "
    "Press ENTER to release the mutex and exit." );
   Console::ReadLine();
   
   // Call ReleaseMutex to allow other threads to gain control
   // of the named mutex. If you keep a reference to the local
   // Mutex, you can call WaitOne to request control of the 
   // named mutex.
   m->ReleaseMutex();
}
// This example shows how a named mutex is used to signal between
// processes or threads.
// Run this program from two (or more) command windows. Each process
// creates a Mutex object that represents the named mutex "MyMutex".
// The named mutex is a system object whose lifetime is bounded by the
// lifetimes of the Mutex objects that represent it. The named mutex
// is created when the first process creates its local Mutex; in this
// example, the named mutex is owned by the first process. The named 
// mutex is destroyed when all the Mutex objects that represent it
// have been released. 
// The second process (and any subsequent process) waits for earlier
// processes to release the named mutex.

using System;
using System.Threading;

public class Test12
{
    public static void Main()
    {
        // Set this variable to false if you do not want to request 
        // initial ownership of the named mutex.
        bool requestInitialOwnership = true;
        bool mutexWasCreated;

        // Request initial ownership of the named mutex by passing
        // true for the first parameter. Only one system object named 
        // "MyMutex" can exist; the local Mutex object represents 
        // this system object. If "MyMutex" is created by this call,
        // then mutexWasCreated contains true; otherwise, it contains
        // false.
        Mutex m = new Mutex(requestInitialOwnership, 
                            "MyMutex", 
                            out mutexWasCreated);
        
        // This thread owns the mutex only if it both requested 
        // initial ownership and created the named mutex. Otherwise,
        // it can request the named mutex by calling WaitOne.
        if (!(requestInitialOwnership && mutexWasCreated))
        {
            Console.WriteLine("Waiting for the named mutex.");
            m.WaitOne();
        }

        // Once the process has gained control of the named mutex,
        // hold onto it until the user presses ENTER.
        Console.WriteLine("This process owns the named mutex. " +
            "Press ENTER to release the mutex and exit.");
        Console.ReadLine();

        // Call ReleaseMutex to allow other threads to gain control
        // of the named mutex. If you keep a reference to the local
        // Mutex, you can call WaitOne to request control of the 
        // named mutex.
        m.ReleaseMutex();
    }
}
' This example shows how a named mutex is used to signal between
' processes or threads.
' Run this program from two (or more) command windows. Each process
' creates a Mutex object that represents the named mutex "MyMutex".
' The named mutex is a system object whose lifetime is bounded by the
' lifetimes of the Mutex objects that represent it. The named mutex
' is created when the first process creates its local Mutex; in this
' example, the named mutex is owned by the first process. The named 
' mutex is destroyed when all the Mutex objects that represent it
' have been released. 
' The second process (and any subsequent process) waits for earlier
' processes to release the named mutex.

Imports System.Threading

Public Class Test
   
   <MTAThread> _
   Public Shared Sub Main()
      ' Set this variable to false if you do not want to request 
      ' initial ownership of the named mutex.
      Dim requestInitialOwnership As Boolean = True
      Dim mutexWasCreated As Boolean
      
      ' Request initial ownership of the named mutex by passing
      ' true for the first parameter. Only one system object named 
      ' "MyMutex" can exist; the local Mutex object represents 
      ' this system object. If "MyMutex" is created by this call,
      ' then mutexWasCreated contains true; otherwise, it contains
      ' false.
      Dim m As New Mutex(requestInitialOwnership, "MyMutex", _
          mutexWasCreated)
      
      ' This thread owns the mutex only if it both requested 
      ' initial ownership and created the named mutex. Otherwise,
      ' it can request the named mutex by calling WaitOne.
      If Not (requestInitialOwnership And mutexWasCreated) Then
         Console.WriteLine("Waiting for the named mutex.")
         m.WaitOne()
      End If
      
      ' Once the process has gained control of the named mutex,
      ' hold onto it until the user presses ENTER.
      Console.WriteLine("This process owns the named mutex. " _
          & "Press ENTER to release the mutex and exit.")
      Console.ReadLine()
      
      ' Call ReleaseMutex to allow other threads to gain control
      ' of the named mutex. If you keep a reference to the local
      ' Mutex, you can call WaitOne to request control of the 
      ' named mutex.
      m.ReleaseMutex()
   End Sub
End Class

Comentarios

name puede tener el prefijo o Global\Local\ especificar un espacio de nombres. Cuando se especifica el Global espacio de nombres, el objeto de sincronización se puede compartir con cualquier proceso del sistema. Cuando se especifica el Local espacio de nombres , que también es el valor predeterminado cuando no se especifica ningún espacio de nombres, el objeto de sincronización se puede compartir con procesos en la misma sesión. En Windows, una sesión es una sesión de inicio de sesión y los servicios normalmente se ejecutan en una sesión no interactiva diferente. En sistemas operativos similares a Unix, cada shell tiene su propia sesión. Los objetos de sincronización local de sesión pueden ser adecuados para sincronizar entre procesos con una relación primaria o secundaria en la que se ejecutan en la misma sesión. Para obtener más información sobre los nombres de objetos de sincronización en Windows, vea Nombres de objeto.

Si se proporciona y name ya existe un objeto de sincronización del tipo solicitado en el espacio de nombres, se usa el objeto de sincronización existente. Si ya existe un objeto de sincronización de un tipo diferente en el espacio de nombres , se produce una WaitHandleCannotBeOpenedException excepción . De lo contrario, se crea un nuevo objeto de sincronización.

Si name no null es y initiallyOwned es true, el subproceso que realiza la llamada posee la exclusión mutua con nombre solo si createdNew es true después de la llamada. De lo contrario, el subproceso puede solicitar la exclusión mutua llamando al WaitOne método .

Este constructor inicializa un Mutex objeto que representa una exclusión mutua del sistema con nombre. Puede crear varios Mutex objetos que representen la misma exclusión mutua del sistema con nombre.

Si la exclusión mutua con nombre ya se ha creado con seguridad de control de acceso y el autor de la llamada no tiene MutexRights.FullControl derechos, se produce una excepción. Para abrir una exclusión mutua con nombre existente solo con los permisos necesarios para sincronizar las actividades de subproceso, consulte el OpenExisting método .

Si especifica null o una cadena vacía para name, se crea una exclusión mutua local, como si hubiera llamado al Mutex(Boolean) constructor . En este caso, createdNew siempre truees .

Dado que son de todo el sistema, las exclusión mutuas con nombre se pueden usar para coordinar el uso de recursos a través de los límites del proceso.

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 es 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 exclusión mutua cuyos nombres solo difieren por sus prefijos son exclusiones 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 sin salir 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 las exclusión 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 el uso de exclusión mutua con nombre sin restricciones de acceso en sistemas que podrían tener usuarios que no son de confianza que ejecutan 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 según se especifica en la nota sobre el uso de exclusión mutua 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.

Consulte también

Se aplica a

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.

public:
 Mutex(bool initiallyOwned, System::String ^ name, [Runtime::InteropServices::Out] bool % createdNew, System::Security::AccessControl::MutexSecurity ^ mutexSecurity);
public Mutex (bool initiallyOwned, string name, out bool createdNew, System.Security.AccessControl.MutexSecurity mutexSecurity);
[System.Security.SecurityCritical]
public Mutex (bool initiallyOwned, string name, out bool createdNew, System.Security.AccessControl.MutexSecurity mutexSecurity);
new System.Threading.Mutex : bool * string * bool * System.Security.AccessControl.MutexSecurity -> System.Threading.Mutex
[<System.Security.SecurityCritical>]
new System.Threading.Mutex : bool * string * bool * System.Security.AccessControl.MutexSecurity -> System.Threading.Mutex
Public Sub New (initiallyOwned As Boolean, name As String, ByRef createdNew As Boolean, mutexSecurity As MutexSecurity)

Parámetros

initiallyOwned
Boolean

true para otorgar al subproceso que realiza la llamada la propiedad inicial de la exclusión mutua del sistema con nombre si esta se crea como resultado de dicha llamada; de lo contrario, false.

name
String

Nombre, si el objeto de sincronización se va a compartir con otros procesos; en caso contrario, null o una cadena vacía. El nombre distingue entre mayúsculas y minúsculas. El carácter de barra diagonal inversa (\) está reservado y solo se puede usar para especificar un espacio de nombres. Para obtener más información sobre los espacios de nombres, consulte la sección comentarios. Puede haber más restricciones en el nombre en función del sistema operativo. Por ejemplo, en los sistemas operativos basados en Unix, el nombre después de excluir el espacio de nombres debe ser un nombre de archivo válido.

createdNew
Boolean

Cuando se devuelve este método, contiene un valor booleano que es true si se creó una exclusión mutua local (es decir, si name es null o una cadena vacía) o si se creó la exclusión mutua del sistema con nombre especificada; el valor es false si la exclusión mutua del sistema con nombre especificada ya existía. Este parámetro se pasa sin inicializar.

mutexSecurity
MutexSecurity

Objeto MutexSecurity que representa la seguridad del control de acceso que se va a aplicar a la exclusión mutua del sistema con nombre.

Atributos

Excepciones

name no es válido. Esto puede deberse a diversos motivos, incluidas algunas restricciones que puede imponer el sistema operativo, como un prefijo desconocido o caracteres no válidos. Tenga en cuenta que el nombre y los prefijos comunes "Global\" y "Local\" distinguen mayúsculas de minúsculas.

O bien

Hubo algún otro error. La propiedad HResult puede proporcionar más información.

Solo Windows: name especificó un espacio de nombres desconocido. Consulte Nombres de objetos para obtener más información.

name es demasiado largo. Las restricciones de longitud pueden depender del sistema operativo o la configuración.

La exclusión mutua con nombre existe y tiene seguridad de control de acceso, pero el usuario no tiene FullControl.

No se puede crear un objeto de sincronización con el valor name proporcionado. Un objeto de sincronización de un tipo diferente podría tener el mismo nombre.

Solo .NET Framework: name es mayor que MAX_PATH (260 caracteres).

Ejemplos

En el ejemplo de código siguiente se muestra el comportamiento entre procesos de una exclusión mutua con nombre con seguridad de control de acceso. En el ejemplo se usa la sobrecarga del OpenExisting(String) método para probar la existencia de una exclusión mutua con nombre.

Si la exclusión mutua no existe, se crea con la propiedad inicial y la seguridad de control de acceso que deniega al usuario actual el derecho de usar la exclusión mutua, pero concede el derecho a leer y cambiar permisos en la exclusión mutua.

Si ejecuta el ejemplo compilado desde dos ventanas de comandos, la segunda copia iniciará una excepción de infracción de acceso en la llamada a OpenExisting(String). La excepción se detecta y el ejemplo usa la sobrecarga del OpenExisting(String, MutexRights) método para abrir la exclusión mutua con los derechos necesarios para leer y cambiar los permisos.

Una vez cambiados los permisos, la exclusión mutua se abre con los derechos necesarios para escribirlo y liberarlo. Si ejecuta el ejemplo compilado desde una tercera ventana de comandos, se ejecuta con los nuevos permisos.

using namespace System;
using namespace System::Threading;
using namespace System::Security::AccessControl;
using namespace System::Security::Permissions;

public ref class Example
{
public:
   [SecurityPermissionAttribute(SecurityAction::Demand,Flags=SecurityPermissionFlag::UnmanagedCode)]
   static void Main()
   {
      String^ mutexName = L"MutexExample4";

      Mutex^ m = nullptr;
      bool doesNotExist = false;
      bool unauthorized = false;
      
      // The value of this variable is set by the mutex
      // constructor. It is true if the named system mutex was
      // created, and false if the named mutex already existed.
      //
      bool mutexWasCreated = false;

      // Attempt to open the named mutex.
      try
      {
         // Open the mutex with (MutexRights.Synchronize |
         // MutexRights.Modify), to enter and release the
         // named mutex.
         //
         m = Mutex::OpenExisting( mutexName );
      }
      catch ( WaitHandleCannotBeOpenedException^ ) 
      {
         Console::WriteLine( L"Mutex does not exist." );
         doesNotExist = true;
      }
      catch ( UnauthorizedAccessException^ ex ) 
      {
         Console::WriteLine( L"Unauthorized access: {0}", ex->Message );
         unauthorized = true;
      }

      // There are three cases: (1) The mutex does not exist.
      // (2) The mutex exists, but the current user doesn't
      // have access. (3) The mutex exists and the user has
      // access.
      //
      if ( doesNotExist )
      {
         // The mutex does not exist, so create it.
         // Create an access control list (ACL) that denies the
         // current user the right to enter or release the
         // mutex, but allows the right to read and change
         // security information for the mutex.
         //
         String^ user = String::Concat( Environment::UserDomainName, L"\\",
            Environment::UserName );
         MutexSecurity^ mSec = gcnew MutexSecurity;

         MutexAccessRule^ rule = gcnew MutexAccessRule( user,
            static_cast<MutexRights>(
               MutexRights::Synchronize |
               MutexRights::Modify),
            AccessControlType::Deny );
         mSec->AddAccessRule( rule );

         rule = gcnew MutexAccessRule( user,
            static_cast<MutexRights>(
               MutexRights::ReadPermissions |
                MutexRights::ChangePermissions),
            AccessControlType::Allow );
         mSec->AddAccessRule( rule );
         
         // Create a Mutex object that represents the system
         // mutex named by the constant 'mutexName', with
         // initial ownership for this thread, and with the
         // specified security access. The Boolean value that
         // indicates creation of the underlying system object
         // is placed in mutexWasCreated.
         //
         m = gcnew Mutex( true,mutexName, mutexWasCreated,mSec );
         
         // If the named system mutex was created, it can be
         // used by the current instance of this program, even
         // though the current user is denied access. The current
         // program owns the mutex. Otherwise, exit the program.
         //
         if ( mutexWasCreated )
         {
            Console::WriteLine( L"Created the mutex." );
         }
         else
         {
            Console::WriteLine( L"Unable to create the mutex." );
            return;
         }
      }
      else if ( unauthorized )
      {
         // Open the mutex to read and change the access control
         // security. The access control security defined above
         // allows the current user to do this.
         //
         try
         {
            m = Mutex::OpenExisting( mutexName,
               static_cast<MutexRights>(
                  MutexRights::ReadPermissions |
                  MutexRights::ChangePermissions) );
            
            // Get the current ACL. This requires
            // MutexRights.ReadPermissions.
            MutexSecurity^ mSec = m->GetAccessControl();

            String^ user = String::Concat( Environment::UserDomainName,
               L"\\", Environment::UserName );
            
            // First, the rule that denied the current user
            // the right to enter and release the mutex must
            // be removed.
            MutexAccessRule^ rule = gcnew MutexAccessRule( user,
               static_cast<MutexRights>(
                  MutexRights::Synchronize |
                  MutexRights::Modify),
               AccessControlType::Deny );
            mSec->RemoveAccessRule( rule );
            
            // Now grant the user the correct rights.
            //
            rule = gcnew MutexAccessRule( user,
               static_cast<MutexRights>(
                  MutexRights::Synchronize |
                  MutexRights::Modify),
               AccessControlType::Allow );
            mSec->AddAccessRule( rule );
            
            // Update the ACL. This requires
            // MutexRights.ChangePermissions.
            m->SetAccessControl( mSec );

            Console::WriteLine( L"Updated mutex security." );
            
            // Open the mutex with (MutexRights.Synchronize
            // | MutexRights.Modify), the rights required to
            // enter and release the mutex.
            //
            m = Mutex::OpenExisting( mutexName );
         }
         catch ( UnauthorizedAccessException^ ex ) 
         {
            Console::WriteLine(
               L"Unable to change permissions: {0}", ex->Message );
            return;
         }
      }
      
      // If this program created the mutex, it already owns
      // the mutex.
      //
      if ( !mutexWasCreated )
      {
         // Enter the mutex, and hold it until the program
         // exits.
         //
         try
         {
            Console::WriteLine( L"Wait for the mutex." );
            m->WaitOne();
            Console::WriteLine( L"Entered the mutex." );
         }
         catch ( UnauthorizedAccessException^ ex ) 
         {
            Console::WriteLine( L"Unauthorized access: {0}",
               ex->Message );
         }
      }

      Console::WriteLine( L"Press the Enter key to exit." );
      Console::ReadLine();
      m->ReleaseMutex();
      m->Dispose();
   }
};

int main()
{
   Example::Main();
}
using System;
using System.Threading;
using System.Security.AccessControl;

internal class Example
{
    internal static void Main()
    {
        const string mutexName = "MutexExample4";

        Mutex m = null;
        bool doesNotExist = false;
        bool unauthorized = false;

        // The value of this variable is set by the mutex
        // constructor. It is true if the named system mutex was
        // created, and false if the named mutex already existed.
        //
        bool mutexWasCreated = false;

        // Attempt to open the named mutex.
        try
        {
            // Open the mutex with (MutexRights.Synchronize |
            // MutexRights.Modify), to enter and release the
            // named mutex.
            //
            m = Mutex.OpenExisting(mutexName);
        }
        catch(WaitHandleCannotBeOpenedException)
        {
            Console.WriteLine("Mutex does not exist.");
            doesNotExist = true;
        }
        catch(UnauthorizedAccessException ex)
        {
            Console.WriteLine("Unauthorized access: {0}", ex.Message);
            unauthorized = true;
        }

        // There are three cases: (1) The mutex does not exist.
        // (2) The mutex exists, but the current user doesn't 
        // have access. (3) The mutex exists and the user has
        // access.
        //
        if (doesNotExist)
        {
            // The mutex does not exist, so create it.

            // Create an access control list (ACL) that denies the
            // current user the right to enter or release the 
            // mutex, but allows the right to read and change
            // security information for the mutex.
            //
            string user = Environment.UserDomainName + "\\"
                + Environment.UserName;
            var mSec = new MutexSecurity();

            MutexAccessRule rule = new MutexAccessRule(user, 
                MutexRights.Synchronize | MutexRights.Modify, 
                AccessControlType.Deny);
            mSec.AddAccessRule(rule);

            rule = new MutexAccessRule(user, 
                MutexRights.ReadPermissions | MutexRights.ChangePermissions,
                AccessControlType.Allow);
            mSec.AddAccessRule(rule);

            // Create a Mutex object that represents the system
            // mutex named by the constant 'mutexName', with
            // initial ownership for this thread, and with the
            // specified security access. The Boolean value that 
            // indicates creation of the underlying system object
            // is placed in mutexWasCreated.
            //
            m = new Mutex(true, mutexName, out mutexWasCreated, mSec);

            // If the named system mutex was created, it can be
            // used by the current instance of this program, even 
            // though the current user is denied access. The current
            // program owns the mutex. Otherwise, exit the program.
            // 
            if (mutexWasCreated)
            {
                Console.WriteLine("Created the mutex.");
            }
            else
            {
                Console.WriteLine("Unable to create the mutex.");
                return;
            }
        }
        else if (unauthorized)
        {
            // Open the mutex to read and change the access control
            // security. The access control security defined above
            // allows the current user to do this.
            //
            try
            {
                m = Mutex.OpenExisting(mutexName, 
                    MutexRights.ReadPermissions | MutexRights.ChangePermissions);

                // Get the current ACL. This requires 
                // MutexRights.ReadPermissions.
                MutexSecurity mSec = m.GetAccessControl();
                
                string user = Environment.UserDomainName + "\\"
                    + Environment.UserName;

                // First, the rule that denied the current user 
                // the right to enter and release the mutex must
                // be removed.
                MutexAccessRule rule = new MutexAccessRule(user, 
                     MutexRights.Synchronize | MutexRights.Modify,
                     AccessControlType.Deny);
                mSec.RemoveAccessRule(rule);

                // Now grant the user the correct rights.
                // 
                rule = new MutexAccessRule(user, 
                    MutexRights.Synchronize | MutexRights.Modify,
                    AccessControlType.Allow);
                mSec.AddAccessRule(rule);

                // Update the ACL. This requires
                // MutexRights.ChangePermissions.
                m.SetAccessControl(mSec);

                Console.WriteLine("Updated mutex security.");

                // Open the mutex with (MutexRights.Synchronize 
                // | MutexRights.Modify), the rights required to
                // enter and release the mutex.
                //
                m = Mutex.OpenExisting(mutexName);
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unable to change permissions: {0}",
                    ex.Message);
                return;
            }
        }

        // If this program created the mutex, it already owns
        // the mutex.
        //
        if (!mutexWasCreated)
        {
            // Enter the mutex, and hold it until the program
            // exits.
            //
            try
            {
                Console.WriteLine("Wait for the mutex.");
                m.WaitOne();
                Console.WriteLine("Entered the mutex.");
            }
            catch(UnauthorizedAccessException ex)
            {
                Console.WriteLine("Unauthorized access: {0}", ex.Message);
            }
        }

        Console.WriteLine("Press the Enter key to exit.");
        Console.ReadLine();
        m.ReleaseMutex();
        m.Dispose();
    }
}
Imports System.Threading
Imports System.Security.AccessControl

Friend Class Example

    <MTAThread> _
    Friend Shared Sub Main()
        Const mutexName As String = "MutexExample4"

        Dim m As Mutex = Nothing
        Dim doesNotExist as Boolean = False
        Dim unauthorized As Boolean = False

        ' The value of this variable is set by the mutex
        ' constructor. It is True if the named system mutex was
        ' created, and False if the named mutex already existed.
        '
        Dim mutexWasCreated As Boolean

        ' Attempt to open the named mutex.
        Try
            ' Open the mutex with (MutexRights.Synchronize Or
            ' MutexRights.Modify), to enter and release the
            ' named mutex.
            '
            m = Mutex.OpenExisting(mutexName)
        Catch ex As WaitHandleCannotBeOpenedException
            Console.WriteLine("Mutex does not exist.")
            doesNotExist = True
        Catch ex As UnauthorizedAccessException
            Console.WriteLine("Unauthorized access: {0}", ex.Message)
            unauthorized = True
        End Try

        ' There are three cases: (1) The mutex does not exist.
        ' (2) The mutex exists, but the current user doesn't 
        ' have access. (3) The mutex exists and the user has
        ' access.
        '
        If doesNotExist Then
            ' The mutex does not exist, so create it.

            ' Create an access control list (ACL) that denies the
            ' current user the right to enter or release the 
            ' mutex, but allows the right to read and change
            ' security information for the mutex.
            '
            Dim user As String = Environment.UserDomainName _ 
                & "\" & Environment.UserName
            Dim mSec As New MutexSecurity()

            Dim rule As New MutexAccessRule(user, _
                MutexRights.Synchronize Or MutexRights.Modify, _
                AccessControlType.Deny)
            mSec.AddAccessRule(rule)

            rule = New MutexAccessRule(user, _
                MutexRights.ReadPermissions Or _
                MutexRights.ChangePermissions, _
                AccessControlType.Allow)
            mSec.AddAccessRule(rule)

            ' Create a Mutex object that represents the system
            ' mutex named by the constant 'mutexName', with
            ' initial ownership for this thread, and with the
            ' specified security access. The Boolean value that 
            ' indicates creation of the underlying system object
            ' is placed in mutexWasCreated.
            '
            m = New Mutex(True, mutexName, mutexWasCreated, mSec)

            ' If the named system mutex was created, it can be
            ' used by the current instance of this program, even 
            ' though the current user is denied access. The current
            ' program owns the mutex. Otherwise, exit the program.
            ' 
            If mutexWasCreated Then
                Console.WriteLine("Created the mutex.")
            Else
                Console.WriteLine("Unable to create the mutex.")
                Return
            End If

        ElseIf unauthorized Then

            ' Open the mutex to read and change the access control
            ' security. The access control security defined above
            ' allows the current user to do this.
            '
            Try
                m = Mutex.OpenExisting(mutexName, _
                    MutexRights.ReadPermissions Or _
                    MutexRights.ChangePermissions)

                ' Get the current ACL. This requires 
                ' MutexRights.ReadPermissions.
                Dim mSec As MutexSecurity = m.GetAccessControl()
                
                Dim user As String = Environment.UserDomainName _ 
                    & "\" & Environment.UserName

                ' First, the rule that denied the current user 
                ' the right to enter and release the mutex must
                ' be removed.
                Dim rule As New MutexAccessRule(user, _
                    MutexRights.Synchronize Or MutexRights.Modify, _
                    AccessControlType.Deny)
                mSec.RemoveAccessRule(rule)

                ' Now grant the user the correct rights.
                ' 
                rule = New MutexAccessRule(user, _
                    MutexRights.Synchronize Or MutexRights.Modify, _
                    AccessControlType.Allow)
                mSec.AddAccessRule(rule)

                ' Update the ACL. This requires
                ' MutexRights.ChangePermissions.
                m.SetAccessControl(mSec)

                Console.WriteLine("Updated mutex security.")

                ' Open the mutex with (MutexRights.Synchronize 
                ' Or MutexRights.Modify), the rights required to
                ' enter and release the mutex.
                '
                m = Mutex.OpenExisting(mutexName)

            Catch ex As UnauthorizedAccessException
                Console.WriteLine("Unable to change permissions: {0}", _
                    ex.Message)
                Return
            End Try

        End If

        ' If this program created the mutex, it already owns
        ' the mutex.
        '
        If Not mutexWasCreated Then
            ' Enter the mutex, and hold it until the program
            ' exits.
            '
            Try
                Console.WriteLine("Wait for the mutex.")
                m.WaitOne()
                Console.WriteLine("Entered the mutex.")
            Catch ex As UnauthorizedAccessException
                Console.WriteLine("Unauthorized access: {0}", _
                    ex.Message)
            End Try
        End If

        Console.WriteLine("Press the Enter key to exit.")
        Console.ReadLine()
        m.ReleaseMutex()
        m.Dispose()
    End Sub 
End Class

Comentarios

name puede tener como prefijo Global\ o Local\ especificar un espacio de nombres. Cuando se especifica el Global espacio de nombres, el objeto de sincronización se puede compartir con cualquier proceso del sistema. Cuando se especifica el Local espacio de nombres , que también es el valor predeterminado cuando no se especifica ningún espacio de nombres, el objeto de sincronización se puede compartir con procesos en la misma sesión. En Windows, una sesión es una sesión de inicio de sesión y los servicios normalmente se ejecutan en una sesión no interactiva diferente. En sistemas operativos similares a Unix, cada shell tiene su propia sesión. Los objetos de sincronización local de sesión pueden ser adecuados para sincronizar entre procesos con una relación primaria o secundaria en la que se ejecutan todas en la misma sesión. Para obtener más información sobre los nombres de objetos de sincronización en Windows, vea Nombres de objeto.

Si se proporciona y name ya existe un objeto de sincronización del tipo solicitado en el espacio de nombres , se usa el objeto de sincronización existente. Si ya existe un objeto de sincronización de otro tipo en el espacio de nombres , se produce una WaitHandleCannotBeOpenedException excepción . De lo contrario, se crea un nuevo objeto de sincronización.

Si name no null es y initiallyOwned es true, el subproceso que realiza la llamada posee la exclusión mutua con nombre solo si createdNew es true después de la llamada. De lo contrario, el subproceso puede solicitar la exclusión mutua llamando al WaitOne método .

Use este constructor para aplicar la seguridad del control de acceso a una exclusión mutua del sistema con nombre cuando se crea, lo que impide que otro código controle la exclusión mutua.

Este constructor inicializa un Mutex objeto que representa una exclusión mutua del sistema con nombre. Puede crear varios Mutex objetos que representen la misma exclusión mutua del sistema con nombre.

Si la exclusión mutua del sistema con nombre no existe, se crea con la seguridad de control de acceso especificada. Si existe la exclusión mutua con nombre, se omite la seguridad de control de acceso especificada.

Nota

El autor de la llamada tiene control total sobre el objeto recién creado Mutex aunque mutexSecurity deniega o no conceda derechos de acceso al usuario actual. Sin embargo, si el usuario actual intenta obtener otro Mutex objeto para representar la misma exclusión mutua con nombre, mediante un constructor o el OpenExisting método , se aplica la seguridad del control de acceso de Windows.

Si la exclusión mutua con nombre ya se ha creado con seguridad de control de acceso y el autor de la llamada no tiene MutexRights.FullControl, se produce una excepción. Para abrir una exclusión mutua con nombre existente solo con los permisos necesarios para sincronizar las actividades de subproceso, consulte el OpenExisting método .

Si especifica null o una cadena vacía para name, se crea una exclusión mutua local, como si hubiera llamado al Mutex(Boolean) constructor. En este caso, createdNew siempre truees .

Dado que son en todo el sistema, las exclusiones mutuas con nombre se pueden usar para coordinar el uso de recursos a través de los límites del proceso.

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. Para restringir el acceso a usuarios específicos, puede pasar un MutexSecurity al crear la 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.

Se aplica a