Question

I have a list of objects which will be accessible by many objects across many threads. To ensure thread safety I have made the list and its object read-only. My only concern is the iterators of the List<> object because I remember reading something about iterator thread safety issues. Do I have a problem?

For clarification: in the BarObservable class, the List < Bar > bar is read-only. The individual bars of the list are also read-only. The MarketDataAdaptor class uses BarService to add new bars to BarsObservable class. The diagram doesn’t show this but the IBarObservers are passed a reference to the List < Bar > . They can’t write to it but they do use the iterator of the List. Meanwhile the final bar is updated and once finalized a new bar is added to the end of the list.

Answer 1

As I understand it, you currently provide two immutability guarantees:

1. There is an unchanging reference(s) to a List<Bar> object.
2. The Bar type itself is immutable or is, by convention, instances of it are not mutated after they are added to the list.

Neither of these is sufficient to deal with any concurrent reader / writer scenarios since the List<T> type itself is not thread-safe.

1. If you have multiple unsynchronized writers, you could corrupt the list.
2. If you have a single writer, with reader(s) on other threads, you probably won’t corrupt the list. On the other hand, the readers won’t work correctly. If you’re lucky, iterating the list in the middle of a write will throw a “Collection changed during enumeration” exception. If you’re not, your program will silently lose its functional correctness.

Now you could try synchronizing access to the list with locks, ReaderWriterLockSlims, etc. How you do this will be specific to the Producer / Consumer relationships of your particular situation. For example, you could lock mutation during enumeration by either of these:

1. Hold up an attempt to mutate as long as there is an active undisposed enumerator.
2. Every time an enumerator is requested, block writers. Copy the list to another list; return its enumerator, and then unblock writers.

But I would suggest, if you are on .NET 4.0, to take a look at the thread-safe collection classes in the System.Collections.Concurrent namespace. In particular, you may find the BlockingCollection<T> class to be exactly what you need.

Finally, I would look at the overall design to see if you can solve this problem in a lock-free manner.