C# multithreaded list operations

atomic, c#, multithreading

Solution

There are two possibilities for problems here:

- Newly added items could end up being forgotten immediately, because you clear out and create a new list. Is that an issue? Basically, if `AddElement` and `ClearList` are called at the same time, you have a race condition: either the element will end up in the new list, or in the old (forgotten) one.

- `List<T>` isn't safe for multi-threaded mutation, so if two different threads call `AddElement` at the same time the results aren't guaranteed

Given that you're accessing a shared resource, I would personally hold a lock while accessing it. You'll still need to consider the possibility of clearing the list immediately before/after adding an item though.

EDIT: My comment about it being okay if you're only adding from one thread was already somewhat dubious, for two reasons:

- It's possible (I think!) that you could end up trying to add to a `List<T>` which hadn't been fully constructed yet. I'm not sure, and the .NET 2.0 memory model (as opposed to the one in the ECMA specification) may be strong enough to avoid that, but it's tricky to say.

- It's possible that the adding thread wouldn't "see" the change to the `list` variable immediately, and still add to the old list. Indeed, without any synchronization, it could see the old value forever

When you add "iterating in the GUI" into the mix it gets really tricky - because you can't change the list while you're iterating. The simplest solution to this is probably to provide a method which returns a copy of the list, and the UI can safely iterate over that:

class A
{
    private List<SomeClass> list;
    private readonly object listLock = new object();

    private void ClearList()
    {
        lock (listLock)
        {
            list = new List<SomeClass>();
        }
    }

    private void AddElement()
    {
        lock (listLock)
        {
            list.Add(new SomeClass(...));
        }
    }

    private List<SomeClass> CopyList()
    {
        lock (listLock)
        {
            return new List<SomeClass>(list);
        }
    }

}

Problem

If I have something like this (pseudocode): ``` class A { List<SomeClass> list; private void clearList() { list = new List<SomeClass>(); } private void addElement() { list.Add(new SomeClass(...)); } } ``` is it possible that I run into multithreading problems (or any kind of unexpected behavior) when both functions are executed in parallel? The use case is a list of errors, which could be cleared at any time (by simply assigning a new, empty list). EDIT: My assumptions are - only one thread adds elements - forgotten elements are okay (i.e. race condition between clearing and adding a new element), as long as the clear operation succeeds without problems - .NET 2.0

Original source