으로 IDisposable와 뮤텍스를 포장하고 테스트하지만 테스트는 결코

Question

나는이 같은 IDisposable 클래스와 Mutex을 포장하기 위해 노력하고있어 끝나지 :

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

당신은 내가했습니다 주석 처리 된 코드에서 볼 수 있듯이 시험을 끝내지 못하기 때문에 위의 구현에 맞지 않거나 뭔가 잘못되었습니다. (아마 죽은 자물쇠는 내가 식별 할 수 없거나 충돌 할 수 있습니다. 비동기 예외).

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의 발생 :

이

내가 LINQPad에 맞게 내 테스트입니다. await Task.Delay(..) 후에는 await 성명 이전의 동일한 스레드에 더 이상 있지 않을 수도 있습니다. 따라서 어떤 경우에는 뮤텍스를 소유하지 않은 스레드에서 뮤텍스를 릴리스하려고합니다. 따라서 문제가됩니다. 즉 이전과 await를 한 후, 현재의 thread를 작성하여 확인하기 쉽습니다 :

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을 확장하고, 해결에 도착, IDisposable와 Mutex을 포장하는 것은 여전히 ​​가능하다. 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(); 
    } 
}