Question

I have this code:

class Program
{
    static void Main(string[] args)
    {
        TestClass instanceOfClass = new TestClass();
        while (true)
        {
            Thread threadTest = new Thread(new ParameterizedThreadStart(AddNewToClass));
            threadTest.Start(instanceOfClass);
        }
    }
    static void AddNewToClass(object parameter)
    {
        var instance = (TestClass)parameter;
        while (true)
        {
            if (instance.Contains(1))
            {
                continue;
            }
            else
            {
                instance.AddNew(1);
            }
        }
    }
}

class TestClass
{
    public Dictionary<int, string> dictionary;
    public TestClass()
    {
        dictionary = new Dictionary<int, string>();
    }
    public void AddNew(int test)
    {
        lock (dictionary)
        {
            dictionary.Add(test, "Test string");
        }
    }
    public bool Contains(int test)
    {
        lock (dictionary)
        {
            if (dictionary.ContainsKey(test))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
    }
}

What I want to do, is to have several different threads that add/remove objects from a Dictionary. I tried running this and I get this exception:

An item with the same key has already been added.

Which seems extremely weird. As far as I know the lock statement should block the dictionary in question and TestClass.Contains(1) should always return true, and it is throwing an exception as it returned true more than once (therefore the exception).

Anyone knows why this might happen? thanks

Answer 1

Your Contains() method is atomic. So is your Add() method. AddNewToClass(), however, is not. One thread may get a result from Contains()…but there’s no guarantee regarding when it might or might not be suspended (or resumed).

That’s your race condition.