我可以从该字典的枚举循环中删除从ConcurrentDictionary项目？ [英] Can I remove items from a ConcurrentDictionary from within an enumeration loop of that dictionary?
问题描述
因此，例如：
ConcurrentDictionary<string,Payload> itemCache = GetItems();
foreach(KeyValuePair<string,Payload> kvPair in itemCache)
{
if(TestItemExpiry(kvPair.Value))
{ // Remove expired item.
Payload removedItem;
itemCache.TryRemove(kvPair.Key, out removedItem);
}
}
显然，与普通的字典，因为枚举的生活中删除项目改变了字典的内部状态，这将抛出一个异常。这是我的理解是，这是不是一个ConcurrentDictionary的情况下所提供的IEnumerable处理内部状态的变化。我是否理解这个权利？有没有更好的方式来使用？
Obviously with an ordinary Dictionary this will throw an exception because removing items changes the dictionary's internal state during the life of the enumeration. It's my understanding that this is not the case for a ConcurrentDictionary as the provided IEnumerable handles internal state changing. Am I understanding this right? Is there a better pattern to use?
推荐答案
很奇怪，我认为你现在已经收到两个答案，似乎确认你不能做到这一点。我只是测试它自己，它工作得很好，没有抛出任何异常。
It's strange to me that you've now received two answers that seem to confirm you can't do this. I just tested it myself and it worked fine without throwing any exception.
下面是code我用来测试的行为，其次是输出（节选，当我pressed'C'清除字典中的foreach 和取值之后立即停止后台线程）。请注意，我把压力的pretty的大量关于这个 ConcurrentDictionary ：每个试图添加一个项目，大约每15毫秒16线程定时器
Below is the code I used to test the behavior, followed by an excerpt of the output (around when I pressed 'C' to clear the dictionary in a foreach and S immediately afterwards to stop the background threads). Notice that I put a pretty substantial amount of stress on this ConcurrentDictionary: 16 threading timers each attempting to add an item roughly every 15 milliseconds.
在我看来，这个类是相当强大的，值得您的关注，如果你工作在一个多线程的情况下。
It seems to me this class is quite robust, and worth your attention if you're working in a multithreaded scenario.
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Threading;
namespace ConcurrencySandbox {
class Program {
private const int NumConcurrentThreads = 16;
private const int TimerInterval = 15;
private static ConcurrentDictionary<int, int> _dictionary;
private static WaitHandle[] _timerReadyEvents;
private static Timer[] _timers;
private static volatile bool _timersRunning;
[ThreadStatic()]
private static Random _random;
private static Random GetRandom() {
return _random ?? (_random = new Random());
}
static Program() {
_dictionary = new ConcurrentDictionary<int, int>();
_timerReadyEvents = new WaitHandle[NumConcurrentThreads];
_timers = new Timer[NumConcurrentThreads];
for (int i = 0; i < _timerReadyEvents.Length; ++i)
_timerReadyEvents[i] = new ManualResetEvent(true);
for (int i = 0; i < _timers.Length; ++i)
_timers[i] = new Timer(RunTimer, _timerReadyEvents[i], Timeout.Infinite, Timeout.Infinite);
_timersRunning = false;
}
static void Main(string[] args) {
Console.Write("Press Enter to begin. Then press S to start/stop the timers, C to clear the dictionary, or Esc to quit.");
Console.ReadLine();
StartTimers();
ConsoleKey keyPressed;
do {
keyPressed = Console.ReadKey().Key;
switch (keyPressed) {
case ConsoleKey.S:
if (_timersRunning)
StopTimers(false);
else
StartTimers();
break;
case ConsoleKey.C:
Console.WriteLine("COUNT: {0}", _dictionary.Count);
foreach (var entry in _dictionary) {
int removedValue;
bool removed = _dictionary.TryRemove(entry.Key, out removedValue);
}
Console.WriteLine("COUNT: {0}", _dictionary.Count);
break;
}
} while (keyPressed != ConsoleKey.Escape);
StopTimers(true);
}
static void StartTimers() {
foreach (var timer in _timers)
timer.Change(0, TimerInterval);
_timersRunning = true;
}
static void StopTimers(bool waitForCompletion) {
foreach (var timer in _timers)
timer.Change(Timeout.Infinite, Timeout.Infinite);
if (waitForCompletion) {
WaitHandle.WaitAll(_timerReadyEvents);
}
_timersRunning = false;
}
static void RunTimer(object state) {
var readyEvent = state as ManualResetEvent;
if (readyEvent == null)
return;
try {
readyEvent.Reset();
var r = GetRandom();
var entry = new KeyValuePair<int, int>(r.Next(), r.Next());
if (_dictionary.TryAdd(entry.Key, entry.Value))
Console.WriteLine("Added entry: {0} - {1}", entry.Key, entry.Value);
else
Console.WriteLine("Unable to add entry: {0}", entry.Key);
} finally {
readyEvent.Set();
}
}
}
}
输出（节选）
cAdded entry: 108011126 - 154069760 // <- pressed 'C'
Added entry: 245485808 - 1120608841
Added entry: 1285316085 - 656282422
Added entry: 1187997037 - 2096690006
Added entry: 1919684529 - 1012768429
Added entry: 1542690647 - 596573150
Added entry: 826218346 - 1115470462
Added entry: 1761075038 - 1913145460
Added entry: 457562817 - 669092760
COUNT: 2232 // <- foreach loop begins
COUNT: 0 // <- foreach loop ends
Added entry: 205679371 - 1891358222
Added entry: 32206560 - 306601210
Added entry: 1900476106 - 675997119
Added entry: 847548291 - 1875566386
Added entry: 808794556 - 1247784736
Added entry: 808272028 - 415012846
Added entry: 327837520 - 1373245916
Added entry: 1992836845 - 529422959
Added entry: 326453626 - 1243945958
Added entry: 1940746309 - 1892917475
另外要注意的是，基于控制台输出，它看起来像的foreach 环路锁定了试图值添加到字典中的其他线程。 （我可能是错的，但否则我就已经猜到你会看到一堆的COUNT字里行间添加项行。）
Also note that, based on the console output, it looks like the foreach loop locked out the other threads that were trying to add values to the dictionary. (I could be wrong, but otherwise I would've guessed you would've seen a bunch of "Added entry" lines between the "COUNT" lines.)
这篇关于我可以从该字典的枚举循环中删除从ConcurrentDictionary项目？的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
