结束语与IDisposable的互斥和测试，但测试永远不会结束

Question

我想换一个Mutex与IDisposable类是这样的：

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(); 
     } 
    } 
} 

，你可以从注释掉的代码中，我看到尝试几乎所有我能想到的工作，但是要么是我的测试错误，要么是上面的实现不正确，因为测试要么永远不会结束（可能是一个死锁，我无法识别或崩溃，非同步异常）。

这是我的测试，我适合LINQPad：

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

出现这种情况是因为await。在您的await Task.Delay(..)之后，您可能不再处于await声明之前的同一线程。所以在某些情况下，你试图从不拥有它的线程释放你的互斥体 - 因此你的问题。这很容易通过前，等待后面写当前线程验证：

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

要扩大Evk's answer，并得到一个解决方法，仍然可以包装一个Mutex与IDisposable。您只需确保您完全控制正在获取Mutex并释放它的Thread，并且您必须确保在获取和释放互斥锁之间上下文不会在该线程中切换。

所以，只需旋转自己的线程。喜欢的东西：

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(); 
    } 
}