Win32: ¿Cómo obtener el proceso/thread que posee un mutex?

Question

Estoy trabajando en una aplicación de la cual solo debe existir una instancia en un momento dado. Hay varias posibilidades de lograr esto:

• Verificar los procesos en ejecución para uno que coincida con el nombre de nuestro EXE (no fiable)
• Encuentra la ventana principal (no fiable, y no siempre tienen una ventana principal)
• Cree un mutex con un nombre único (GUID)

La opción mutex me parece la más confiable y elegante.

Sin embargo, antes de que termine mi segunda instancia, deseo enviar un mensaje a la instancia que ya se está ejecutando. Para esto, necesito un control para el hilo (o el proceso) que posee el mutex.

Sin embargo, parece que no hay una función API para obtener el creador/propietario de un mutex determinado. ¿Acabo de pasarlo por alto? ¿Hay alguna otra manera de llegar a este hilo/proceso? ¿Hay alguna otra manera de hacerlo?

actualización: This guy simplemente difundir un mensaje a todos los procesos en ejecución. Supongo que es posible, pero realmente no me gusta ...

Answer 1

no creo hay una forma trivial de resolver el propietario real de un Mutex, pero el proceso que lo posee puede crear otros elementos secundarios cuyas vidas están ligadas a él. Hay muchos mecanismos que son adecuados para devolver la llamada a través del proceso sin tener una ventana principal.

1. Registre un objeto en la tabla de objetos ejecutables COM. Los clientes que no pueden tomar posesión del Mutex pueden buscar al propietario a través del ROT y devolver la llamada al propietario. Un File Moniker debería ser adecuado para registrarse aquí.
2. Crea un fragmento de memoria compartida que contiene detalles de ubicación para el proceso de propietario. A partir de ahí, escriba en el búfer el identificador de proceso y el manejador de subprocesos de un subproceso que puede recibir mensajes de Windows, y luego use PostThreadMessage() para enviar una notificación. Cualquier otro proceso competitivo puede abrir la memoria compartida de solo lectura para determinar dónde enviar un mensaje de Windows.
3. Escuche en el proceso del propietario en un zócalo o tubería con nombre. Probablemente exagerado y no un buen partido para sus necesidades.
4. Utilice un archivo compartido con bloqueo. No me gusta esto porque el propietario tendrá que sondear, y no manejará con gracia el potencial de N otros procesos que podrían estar tratando de contactar al propietario al mismo tiempo.

Aquí hay enlaces de referencia para las dos primeras opciones.

1. IRunningObjectTable @ MSDN, File Monikers @ MSDN
2. Creating Named Shared Memory @ MSDN

Answer 2

Nunca he entendido realmente lo racional detrás de usar un Mutex que no tiene capacidad de señalización. En su lugar, crearía un evento (usando CreateEvent) que tiene las mismas propiedades que crear un mutex (es decir, con un nombre puede devolver que el objeto ya existía) pero puede establecer el indicador de evento en el nuevo proceso, siempre que el original proceso está esperando en el indicador de evento, se puede notificar cuando necesita activarse.

Answer 3

Siempre se puede hacer de la manera UNIX y crear un archivo "pid", colocando el ID de proceso de la instancia que se está ejecutando actualmente en ese archivo. Luego haga que la aplicación elimine el archivo cuando salga.

Cuando una nueva instancia se pone en marcha se debe verificar que el proceso en el archivo PID es en realidad viva, así (en el caso de la aplicación sale de manera anormal y el archivo no se borran)

Answer 4

Esto debe empezar en la solicitud original para obtener un proceso que posee un mutex.

Está en C#, pero las llamadas de Win32 son las mismas.

class HandleInfo 
{ 
    [DllImport("ntdll.dll", CharSet = CharSet.Auto)] 
    public static extern uint NtQuerySystemInformation(int SystemInformationClass, IntPtr SystemInformation, int SystemInformationLength, out int ReturnLength); 

    [DllImport("kernel32.dll", SetLastError = true)] 
    internal static extern IntPtr VirtualAlloc(IntPtr address, uint numBytes, uint commitOrReserve, uint pageProtectionMode); 

    [DllImport("kernel32.dll", SetLastError=true)] 
    internal static extern bool VirtualFree(IntPtr address, uint numBytes, uint pageFreeMode); 

    [StructLayout(LayoutKind.Sequential)] 
    public struct SYSTEM_HANDLE_INFORMATION 
    { 
     public int ProcessId; 
     public byte ObjectTypeNumber; 
     public byte Flags; // 1 = PROTECT_FROM_CLOSE, 2 = INHERIT 
     public short Handle; 
     public int Object; 
     public int GrantedAccess; 
    } 

    static uint MEM_COMMIT = 0x1000; 
    static uint PAGE_READWRITE = 0x04; 
    static uint MEM_DECOMMIT = 0x4000; 
    static int SystemHandleInformation = 16; 
    static uint STATUS_INFO_LENGTH_MISMATCH = 0xC0000004; 

    public HandleInfo() 
    { 
     IntPtr memptr = VirtualAlloc(IntPtr.Zero, 100, MEM_COMMIT, PAGE_READWRITE); 

     int returnLength = 0; 
     bool success = false; 

     uint result = NtQuerySystemInformation(SystemHandleInformation, memptr, 100, out returnLength); 
     if (result == STATUS_INFO_LENGTH_MISMATCH) 
     { 
      success = VirtualFree(memptr, 0, MEM_DECOMMIT); 
      memptr = VirtualAlloc(IntPtr.Zero, (uint)(returnLength + 256), MEM_COMMIT, PAGE_READWRITE); 
      result = NtQuerySystemInformation(SystemHandleInformation, memptr, returnLength, out returnLength); 
     } 

     int handleCount = Marshal.ReadInt32(memptr); 
     SYSTEM_HANDLE_INFORMATION[] returnHandles = new SYSTEM_HANDLE_INFORMATION[handleCount]; 

     using (StreamWriter sw = new StreamWriter(@"C:\NtQueryDbg.txt")) 
     { 
      sw.WriteLine("@ Offset\tProcess Id\tHandle Id\tHandleType"); 
      for (int i = 0; i < handleCount; i++) 
      { 
       SYSTEM_HANDLE_INFORMATION thisHandle = (SYSTEM_HANDLE_INFORMATION)Marshal.PtrToStructure(
        new IntPtr(memptr.ToInt32() + 4 + i * Marshal.SizeOf(typeof(SYSTEM_HANDLE_INFORMATION))), 
        typeof(SYSTEM_HANDLE_INFORMATION)); 
       sw.WriteLine("{0}\t{1}\t{2}\t{3}", i.ToString(), thisHandle.ProcessId.ToString(), thisHandle.Handle.ToString(), thisHandle.ObjectTypeNumber.ToString()); 
      } 
     } 

     success = VirtualFree(memptr, 0, MEM_DECOMMIT); 
    } 
} 

Answer 5

Crear un área de memoria compartida con el nombre fijo:

http://msdn.microsoft.com/en-us/library/aa366551%28VS.85%29.aspx

entonces usted puede poner cualquier estructura te gusta el interior, incluyendo identificador de proceso, etc. HWND

Hay una opción portátil: crea un socket en un puerto (con un número fijo) y espera (acepta) en él. La segunda instancia de la aplicación fallará ya que el puerto ya está ocupado. Luego, la segunda instancia puede conectarse al socket de la instancia principal y enviar la información deseada.

Espero que esto ayude ...