Wrapping ein Mutex mit IDisposable und es zu testen, aber der Test endet nie

Question

Ich versuche, ein Mutex mit einer IDisposable Klasse wie folgt zu wickeln:

public class NamedMutex : IDisposable 
{ 
    private static readonly object _syncLock = new object(); 
    private readonly Mutex _namedMutex; 
    private readonly bool _createdNew; 

    public NamedMutex(string name) 
    { 
     if (string.IsNullOrEmpty(name)) throw new ArgumentNullException("name"); 
     //lock (_syncLock) 
     { 
      _namedMutex = new Mutex(initiallyOwned: false, name: name, createdNew: out _createdNew); 
     } 
     _namedMutex.WaitOne(); 
    } 

    public void Dispose() 
    { 
     //lock (_syncLock) 
     { 
      //if (_createdNew) 
      _namedMutex.ReleaseMutex(); 
      _namedMutex.Dispose(); 
     } 
    } 
} 

, wie Sie aus dem Kommentar gesetzt Code sehen ich habe habe so ziemlich alles ausprobiert, was ich mir vorstellen konnte, aber entweder ist mein Test falsch oder etwas stimmt nicht mit der obigen Implementierung, weil der Test nie endet (wahrscheinlich ein Deadlock, den ich nicht identifizieren kann oder mit dem es abstürzt) unsynchronisierte Ausnahme).

Dies ist mein Test, den ich für LINQPad angepasst:

void Main() 
{ 
    var sw = Stopwatch.StartNew(); 

    var task1 = Task.Run(async() => 
    { 
     using (new NamedMutex("foo")) 
     { 
      Console.WriteLine(3); 
      await Task.Delay(TimeSpan.FromSeconds(3)); 
     } 
    }); 

    var task2 = Task.Run(async() => 
    { 
     using (new NamedMutex("foo")) 
     { 
      Console.WriteLine(2); 
      await Task.Delay(TimeSpan.FromSeconds(2)); 
     } 
    }); 

    Task.WaitAll(task1, task2); 

    //Assert.IsTrue(sw.Elapsed.TotalSeconds >= 5); 
    sw.Elapsed.Dump(); // LINQPad 
} 

Answer 1

Dies wegen await passiert. Nach Ihrer await Task.Delay(..) Sie möglicherweise nicht mehr auf dem gleichen Thread waren Sie zuvor await Aussage. In einigen Fällen versuchen Sie also, Ihren Mutex aus dem Thread zu entfernen, der ihn nicht besitzt - daher Ihr Problem. Das ist einfach durch das Schreiben aktuellen Thread vor und nach await zu überprüfen:

class Program { 
    public static void Main() { 
     while (true) { 
      var sw = Stopwatch.StartNew(); 

      var task1 = Task.Run(async() => {      
       using (new NamedMutex("foo")) { 
        Console.WriteLine("first before await: " + Thread.CurrentThread.ManagedThreadId); 
        await Task.Delay(TimeSpan.FromSeconds(2)); 
        Console.WriteLine("first after await: " + Thread.CurrentThread.ManagedThreadId); 
       } 
      }); 

      var task2 = Task.Run(async() => {      
       using (new NamedMutex("foo")) { 
        Console.WriteLine("second before await: " + Thread.CurrentThread.ManagedThreadId); 
        await Task.Delay(TimeSpan.FromSeconds(1)); 
        Console.WriteLine("second after await: " + Thread.CurrentThread.ManagedThreadId); 
       } 
      }); 

      Task.WaitAll(task1, task2); 

      //Assert.IsTrue(sw.Elapsed.TotalSeconds >= 5); 
      Console.WriteLine(sw.Elapsed); 
     }    
    } 
} 

Answer 2

Zur Erweiterung auf Evk's answer und zu einer Vermeidung des Problems zu bekommen, ist es immer noch möglich, eine Mutex mit einem IDisposable zu wickeln. Sie müssen nur sicherstellen, dass Sie die vollständige Kontrolle über die Thread haben, die die Mutex erwirbt und freigibt, und Sie müssen sicherstellen, dass der Kontext in diesem Thread zwischen Erwerb und Freigabe des Mutex nicht wechselt.

Also dreh einfach deinen eigenen Thread auf. Etwas wie:

class NamedMutex : IDisposable 
{ 
    private readonly Thread _thread; 
    private readonly ManualResetEventSlim _disposalGate; 
    private readonly Mutex _namedMutex; 
    public NamedMutex(string name) 
    { 
     var constructorGate = new ManualResetEventSlim(); 
     _disposalGate = new ManualResetEventSlim(); 
     _thread = new Thread(() => 
     { 
      // Code here to acquire the mutex 
      _namedMutex = new Mutex(initiallyOwned: false, name: name, createdNew: out _createdNew); 

      constructorGate.Set(); // Tell the constructor it can go on 
      _disposalGate.Wait(); // Wait for .Dispose to be called 

      // Code here to release the mutex 
      _namedMutex.ReleaseMutex(); 
      _namedMutex.Dispose(); 
     }); 
     _thread.Start(); 
     constructorGate.Wait(); 
    } 

    public void Dispose() 
    { 
     _disposalGate.Set(); 
    } 
}