ConcurrentDictionary and Clear()-function. Making values export threadsafe without data-loss

Question

Any ideas of making ConcurrentDictionary threadsafe in condition where values are exported to list ex, and after that dictionary is cleared. So that any other thread cannot add data between exporting and clearing.

Like this: "

List<data> list;
list = (List<data>)_changedItems.Values; //get values before clearing
_changedItems.Clear();

" And adding is done by other threads with function _changedItems.AddOrUpdate

Now there is possibility to lose new data between getting data out from the dictionary and clearing content, if some thread adds data-objects to collection before row of clearing.

Or is the only way to do adding and clearing inside lock.

lock(object)
{
    List<data> list;
    list = (List<data>)_changedItems.Values;  
    _changedItems.Clear();
}

And

lock(object)
    _changedItems.AddOrUpdate

There is need for a Clear-function that returns safely all the cleared items from dictionary..

-Larry

Assign dictionary instance to a local, Create another empty dictionary, lock, overwrite the instance, unlock, return the old one? Only works if all the threads use the same reference - if they have copies by value, this will not work. — Martin James, Jan 24 '12 at 13:29
Another thought - if you can do this, you could use Interlocked.Exchange to swap out the instance, so eliminating the lock. Shortening, or eliminating, locks is always good news for performance, (and deadlock avoidance, though probably not relevant here). — Martin James, Jan 24 '12 at 13:42

Roland Pihlakas · Answer 1 · 2012-05-10T06:09:18.750

You can use TryRemove(key, out value) method. It returns the removed element. This way you do not have to lock the dictionary for moving the buffered data.

List<data> list;
var keys = dict.Keys;
foreach(var key in keys)
{
    data value;
    dict.TryRemove(key, out value);
    list.Add(value);
}

Update: actually you can iterate directly over ConcurrentDictionary even while it is changing. This way you do not have to build the collection of the keys from the property .Keys, which may be (?) slow, depending on implementation.

List<data> list;
foreach(var kvp in dict)
{
    data value;
    dict.TryRemove(kvp.Key, out value);
    list.Add(value);
}

score 2 · Answer 2 · answered Jan 24 '12 at 13:14

2

Indeed, calling two thread-safe methods in a sequence does not guarantee the atomicity of the sequence itself. You are right that a lock over both calls to get values and clear is necessary.

answered Jan 24 '12 at 13:14

Tudor

61,523
12
102
142

ConcurrentDictionary and Clear()-function. Making values export threadsafe without data-loss

2 Answers2