多线程：锁定属性 - 这是正确的吗？

Question

I have written the following code:

static readonly object failedTestLock = new object();

public static Dictionary<string, Exception> FailedTests
{
    get
    {
        lock (failedTestLock)
        {
            return _failedTests;
        }
    }
    set
    {
        lock (failedTestLock)
        {
            _failedTests = value;
        }
    }
}

public void RunTest(string testName)
{
    try
    {
        //Run a test
    }
    catch (Exception exception)
    {
        // ?? Is this correct / threadsafe?
        FailedTests.Add(testName, exception);
    }
}

QUESTION :
Is this a correct manner to safely add the failed test to the Dictionary?
Is this threadsafe?
Is FailedTests.Add called INSIDE the lock or OUTSIDE the lock?

Can you explain why this is correct/threadsafe or why not?

Thanks in advance

Answer 1

The fundamental problem with the code above is that it only locks access to _failedTests when a thread is getting the dictionary or setting it. Only one thread can get a reference to the dictionary at a time, but once a thread has a reference to the dictionary, it can read and manipulate it without being constrained by locks.

Is this a correct manner to safely add the failed test to the Dictionary?

No, not if two threads are trying to add to the dictionary at the same time. Nor if you expect reads and writes to happen in a particular order.

Is this threadsafe?

It depends what you mean by threadsafe , but no, not by any reasonable definition.

Is FailedTests.Add called INSIDE the lock or OUTSIDE the lock?

The dictionary retrieval (the get accessor) happens inside a lock. This code calls Add after releasing the lock.

Can you explain why this is correct/threadsafe or why not?

If multiple threads operate on your dictionary at the same time, you can't predict the order in which those threads will change its contents and you can't control when reads will occur.

Answer 2

This is not thread-safe access to a dictionary, because only the property access that returns the dictionary object is thread-safe, but you are not synchronizing the call to the Add method. Consider using ConcurrentDictionary<string,Exception> in this case, or synchronize calls to Add manually.

Answer 3

I don;t thinks this is threadsafe, because the lock is kept only in the very brief moment where the pointer to the collection is returned. When you Add to the collection there is no lock so if two threads try to add at the same time you'll get a nasty error. So you should lock around the FailedTest.Add code.

You may also want to look into concurrent collections, they might provide what you need.

Regards GJ

Answer 4

The call to Add() is outside the locks.

You can solve it by writing your own Add() method to replace the property.