如何在 C# 中实现和单元测试锁

Question

I have a method that needs to perform some operations atomically, and also no two calls to this method should be executed simultaneously. Here is my attempt to implement a simple lock ( SomeClass is registered as a singleton):

public class SomeClass
{
    private bool isRunning;

    public void DoWork()
    {
        if (this.isRunning)
        {
            return;
        }

        try
        {
            this.isRunning = true;
            // do some work that has to be done atomically and takes some time
        }
        catch (Exception e)
        {
            // handle exception
        }
        finally
        {
            this.isRunning = false;
        }
    }
}

First of all is this correct? Secondly, how can I unit test this?

Answer 1

The problem with your approach is that your thread can be interrupted at any point, many times your code might work, in fact if the actual work is significant, your code will work a very high percentage of the time, however it's not robust, so having a look at your code, if this.isRunning == false .... and two threads try and call DoWork....

           if (this.isRunning)
                {
                    return;
                }
    // first thread gets to here, and gets context switched, then that means 
    // second thread will get to here also as isRunning is still false,
    //  but now we have two threads in this piece of code which is what we wanted to avoid.

                try
                {
// first and second thread will come here now....
                    this.isRunning = true;
// and both will go on to do work....

The framework provides standard Thread primitives that will stop that from happening. So, I've separated the critical section out into a separate class (JustOne) so you can test it independently of your work code.

public class JustOne
{
    private Object _lock = new Object();

    public bool Do(Action action)
    {
        bool lockTaken = false;
        try
        {
            Monitor.TryEnter(_lock, ref lockTaken);
            if (lockTaken)
            {
                action();
            }
            else
            {
                return false;
            }
        }
        finally
        {
            if (lockTaken)
            {
                Monitor.Exit(_lock);
            }
        }

        return true;
    }
}

Then your class looks like

public class SomeClass
 {
     private readonly JustOne _work;
     public SomeClass()
     {
         _work = new JustOne();
     }

     public bool DoWork()
     {
         return _work.Do(() =>
         {
             // actual work
         });
     }

 }

now you can test JustOne with something like

        public void TestLock()
        {
            var first = new AutoResetEvent(false);
            var second = new AutoResetEvent(false);
            var work = new JustOne();
            var t = Task.Run(() => work.Do(() =>
            {
                first.Set();
                second.WaitOne();
            }));
            first.WaitOne();
            Assert.False(work.Do(() => { }));
            second.Set();
            t.Wait();
        }