检测死锁WinForms应用程序

Question

we have a quite large winforms desktop application. Our application runs every once in a while into a deadlock and we are not sure how this happens.

We do know that this is caused by a locking operation. So we have quite a lot code parts like this:

lock (_someObj)
  DoThreadSaveOperation();

Our approach to be able to detect what the deadlock was caused by we want to convert all those lock operations into something like this:

bool lockTaken = false;   
var temp = _someObj;
try {   
    System.Threading.Monitor.TryEnter(temp, 1000, ref lockTaken);
    if (!lockTaken)
    {
      // log "can't get lock, maybe deadlock, print stacktrace
    }
    DoThreadSaveOperation();
}   
finally {   
   System.Threading.Monitor.Exit(temp);   
}  

This "lock service" should be at a central position. The problem is that it then has to be called like this:

  LockService.RunWithLock(object objToLock, Action methodToRun);

That would mean that we had to create a delegate function for each statement which is executed after a lock.

Since this would be a lot of refactoring, I thought I'd give a try on stackoverflow if you guys have a better/good idea about this and also ask for your opinion.

Thanks for you help =)

Answer 1

Since the existing lock functionality closely models a using statement, I suggest that you wrap up your logic in a class that implements IDisposable.

The class's constructor would attempt to get the lock, and if it failed to get the lock you could either throw an exception or log it. The Dispose() method would release the lock.

You would use it in a using statement so it will be robust in the face of exceptions.

So something like this:

public sealed class Locker: IDisposable
{
    readonly object _lockObject;
    readonly bool _wasLockAcquired;

    public Locker(object lockObject, TimeSpan timeout)
    {
        _lockObject = lockObject;
        Monitor.TryEnter(_lockObject, timeout, ref _wasLockAcquired);

        // Throw if lock wasn't acquired?
    }

    public bool WasLockAquired
    {
        get
        {
            return _wasLockAcquired;
        }
    }

    public void Dispose()
    {
        if (_wasLockAcquired)
            Monitor.Exit(_lockObject);
    }
}

Which you could use like this:

using (var locker = new Locker(someObj, TimeSpan.FromSeconds(1)))
{
    if (locker.WasLockAquired)
    {
        // ...
    }
}

Which I think will help to minimise your code changes.