¿Probar un bloqueo sin adquirirlo?

Question

Tengo objetos, tienen bloqueos. Quiero probar si están bloqueados sin adquirir un bloqueo. La idea es si TryEnter() ellos tienen que Salir() si es verdadero para verificar solo el bloqueo correctamente.

Parece una pregunta realmente básica, ¿cómo se hace?

Answer 1

¿Qué información posible puede obtener al saber que el candado fue desbloqueado cuando lo miró? En el momento en que tome una decisión basada en esa información, el bloqueo ya puede estar tomado.

Answer 2

Debido a que la instrucción lock es equivalente a:

System.Threading.Monitor.Enter(x); 
try { 
    ... 
} 
finally { 
    System.Threading.Monitor.Exit(x); 
} 

¿Puede usted acaba de hacer esto?

bool ObjectWasUnlocked(object x) 
{ 
    if(System.Threading.Monitor.TryEnter(x)) 
    { 
     System.Threading.Monitor.Exit(x); 
     return true; 
    } 
    else 
    { 
     return false; 
    } 
} 

Nota que estoy nombrando a esta función "objeto Fue desbloqueado" en lugar de "ObjectIsUnlocked". No hay garantía de que todavía se desbloqueará cuando la función haya regresado.

Answer 3

Aquí es una pregunta relacionada

Checking whether the current thread owns a lock

La conclusión no había 'no se puede'

Answer 4

Me preguntaba lo mismo al tratar de auditar el código de bloqueo correcto. Se me ocurrió un método usando un segundo hilo. Si el bloqueo está disponible para el hilo que llama, pero no está disponible para un segundo hilo, debe ser retenido por el primero.

/// <summary> 
/// Utiltity for checking if a lock has already been acquired. 
/// WARNING: This test isn't actually thread-safe, 
/// it's only really useful for unit tests 
/// </summary> 
private static bool ObjectIsAlreadyLockedByThisThread(object lockObject) 
{ 
    if (!Monitor.TryEnter(lockObject)) 
    { 
     // another thread has the lock 
     return false; 
    } 

    Monitor.Exit(lockObject); 

    bool? LockAvailable = null; 

    var T = new Thread(() => 
    { 
     if (Monitor.TryEnter(lockObject)) 
     { 
      LockAvailable = true; 
      Monitor.Exit(lockObject); 
     } 
     else 
     { 
      LockAvailable = false; 
     } 
    }); 

    T.Start(); 

    T.Join(); 

    return !LockAvailable.Value; 
} 

// Tests: 
public static void TestLockedByThisThread() 
{ 
    object MyLock = new object(); 
    lock (MyLock) 
    { 
     bool WasLocked = ObjectIsAlreadyLockedByThisThread(MyLock); 

     Debug.WriteLine(WasLocked); // prints "True" 
    } 
} 

public static void TestLockedByOtherThread() 
{ 
    object MyLock = new object(); 

    var T = new Thread(() => 
    { 
     lock (MyLock) 
     { 
      Thread.Sleep(TimeSpan.FromSeconds(2)); 
     } 
    }); 

    T.Start(); 
    Thread.Sleep(TimeSpan.FromSeconds(1)); 

    bool WasLocked = ObjectIsAlreadyLockedByThisThread(MyLock); 

    T.Join(); 

    Debug.WriteLine(WasLocked); // prints "False" 
} 

public static void TestNotLocked() 
{ 
    object MyLock = new object(); 

    bool WasLocked = ObjectIsAlreadyLockedByThisThread(MyLock); 

    Debug.WriteLine(WasLocked); // prints "False" 
} 

No utilizaría esto en el código de producción: hay una condición de carrera que podría explotar. Sin embargo, mis pruebas unitarias son en su mayoría de un solo hilo, así que esto fue útil.