blocks|key|1668542|text|嗯，ConcurrentDictionary允许多个线程使用它。对我来说，这似乎是完全合理的，这需要更多的内部事务管理，而不是假设它可以逃脱，而不必担心来自多个线程的访问。如果结果相反的话，我会感到非常惊讶--如果更安全的版本也总是更快的话，你为什么会使用不那么安全的版本呢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1668543|entityMap^0|2|K|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Well, <code>ConcurrentDictionary</code> is allowing for the possibility that it can be used by multiple threads. It seems entirely reasonable to me that that requires more internal housekeeping than something which assumes it can get away without worrying about access from multiple threads. I'd have been very surprised if it had worked out the other way round - if the safer version were always faster too, why would you ever use the less safe version?

blocks|key|1872566|text|ConcurrentDictionary<>在创建时创建一组内部锁定对象(除其他因素外，这是由concurrencyLevel确定的)--这组锁定对象用于在一系列细粒度锁中控制对内部桶结构的访问。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1872567|在单线程场景中，不需要锁，因此获取和释放这些锁的额外开销可能是您所看到的差异的根源。|1872568|entityMap^0|0|M|1B|G|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@]|D|@]|E|$]]|$1|H|3|-4|5|6|7|P|8|@]|D|@]|E|$]]]|I|$]]

The <code>ConcurrentDictionary&lt;&gt;</code> creates an internal set of locking objects at creation (this is determined by the <code>concurrencyLevel</code>, amongst other factors) - this set of locking objects is used to control access to the internal bucket structures in a series of fine-grained locks.

In a single threaded scenario, there would be no need for the locks, so the extra overhead of acquiring and releasing these locks is probably the source of the difference you're seeing.

blocks|key|1872605|text|最可能的原因是，对于相同的操作，ConcurrentDictionary比Dictionary具有更多的开销。如果您深入了解这些来源，这显然是正确的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1872606|它为索引器使用一个锁。|unordered-list-item|1872607|它使用易失性写入。|1872608|它必须对在.Net中不一定是原子的值进行原子写入。|1872609|它在核心添加例程中有额外的分支(无论是使用锁，还是执行原子写入)|1872610|1872611|1872612|所有这些成本都是发生的，而不管在多少线程上使用它。这些费用个别来说可能很小，但并不是免费的，而且随着时间的推移也会增加。|1872613|entityMap^0|G|K|11|A|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$]]|$1|I|3|J|5|H|7|10|8|@]|D|@]|E|$]]|$1|K|3|L|5|H|7|11|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|12|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|13|8|@]|D|@]|E|$]]|$1|P|3|-4|5|6|7|14|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|15|8|@]|D|@]|E|$]]|$1|S|3|-4|5|6|7|16|8|@]|D|@]|E|$]]]|T|$]]

The most likely reason that <code>ConcurrentDictionary</code> simply has more overhead than <code>Dictionary</code> for the same operation. This is demonstrably true if you dig into the sources

<ul>
<li>It uses a lock for the indexer</li>
<li>It uses volatile writes </li>
<li>It has to do atomic writes of values which are not guaranteed to be atomic in .Net</li>
<li>It has extra branches in the core add routine (whether to take a lock, do atomic write)</li>
</ul>

All of these costs are incurred irrespective of the number of threads that it's being used on. These costs may be individually small but aren't free and do add up over time

blocks|key|1668725|text|ConcurrentDictionary与字典
通常，在从多个线程同时添加和更新键或值的任何场景中，都要使用System.Collections.Concurrent.ConcurrentDictionary。在涉及频繁更新和相对较少读取的场景中，ConcurrentDictionary通常提供一些小的好处。在涉及许多读取和更新的场景中，在具有任意数量核心的计算机上，ConcurrentDictionary通常要快得多。
在涉及频繁更新的方案中，您可以增加ConcurrentDictionary中的并发度，然后度量是否在具有更多核心的计算机上性能提高。如果更改并发级别，请尽可能避免全局操作。
如果您只读取键或值，则字典会更快，因为如果字典没有被任何线程修改，则不需要同步。
|type|blockquote|depth|inlineStyleRanges|entityRanges|data|1668726|unstyled|1668727|链接：https://msdn.microsoft.com/en-us/library/dd997373%2528v=vs.110%2529.aspx|offset|length|1668728|entityMap|0|LINK|mutability|MUTABLE|url|https://msdn.microsoft.com/en-us/library/dd997373%2528v=vs.110%2529.aspx^0|0|0|3|1W|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|-4|5|C|7|Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|C|7|R|8|@]|9|@$F|S|G|T|1|U]]|A|$]]|$1|H|3|-4|5|C|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

<blockquote>
 ConcurrentDictionary vs. Dictionary
 
 In general, use a
 System.Collections.Concurrent.ConcurrentDictionary in
 any scenario where you are adding and updating keys or values
 concurrently from multiple threads. In scenarios that involve frequent
 updates and relatively few reads, the ConcurrentDictionary generally offers modest benefits. In scenarios that involve
 many reads and many updates, the ConcurrentDictionary
 generally is significantly faster on computers that have any number of
 cores.
 
 In scenarios that involve frequent updates, you can increase the
 degree of concurrency in the ConcurrentDictionary and
 then measure to see whether performance increases on computers that
 have more cores. If you change the concurrency level, avoid global
 operations as much as possible.
 
 If you are only reading key or values, the Dictionary is
 faster because no synchronization is required if the dictionary is not
 being modified by any threads.
</blockquote>

Link: <a href="https://msdn.microsoft.com/en-us/library/dd997373%28v=vs.110%29.aspx" rel="nofollow">https://msdn.microsoft.com/en-us/library/dd997373%28v=vs.110%29.aspx</a>

blocks|key|1668749|text|你的测试是错误的:你必须停止秒表之前！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1668750|++++++++Stopwatch+sw+=+new+Stopwatch();++++++
++++++++sw.Start();
++++++++var+d+=+new+ConcurrentDictionary<int,+int>();
++++++++for+(int+i+=+0;+i+<+1000000;+i%2B%2B)+d[i]+=+123;
++++++++for+(int+i+=+1000000;+i+<+2000000;+i%2B%2B)+d[i]+=+123;
++++++++for+(int+i+=+2000000;+i+<+3000000;+i%2B%2B)+d[i]+=+123;
++++++++sw.Stop();
++++++++Console.WriteLine("baseline+=+"+%2B+sw.Elapsed);



++++++++sw.Start();
++++++++var+d2+=+new+Dictionary<int,+int>();
++++++++for+(int+i+=+0;+i+<+1000000;+i%2B%2B)+lock+(d2)+d2[i]+=+123;
++++++++for+(int+i+=+1000000;+i+<+2000000;+i%2B%2B)+lock+(d2)+d2[i]+=+123;
++++++++for+(int+i+=+2000000;+i+<+3000000;+i%2B%2B)+lock+(d2)+d2[i]+=+123;
++++++++sw.Stop();
++++++++Console.WriteLine("baseline+=+"+%2B+sw.Elapsed);

++++++++sw.Stop();|code-block|syntax|javascript|1668751|-产出：|1668752|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Your test is wrong : you must stop the Stopwatch before !

<pre><code> Stopwatch sw = new Stopwatch(); 
 sw.Start();
 var d = new ConcurrentDictionary&lt;int, int&gt;();
 for (int i = 0; i &lt; 1000000; i++) d[i] = 123;
 for (int i = 1000000; i &lt; 2000000; i++) d[i] = 123;
 for (int i = 2000000; i &lt; 3000000; i++) d[i] = 123;
 sw.Stop();
 Console.WriteLine("baseline = " + sw.Elapsed);



 sw.Start();
 var d2 = new Dictionary&lt;int, int&gt;();
 for (int i = 0; i &lt; 1000000; i++) lock (d2) d2[i] = 123;
 for (int i = 1000000; i &lt; 2000000; i++) lock (d2) d2[i] = 123;
 for (int i = 2000000; i &lt; 3000000; i++) lock (d2) d2[i] = 123;
 sw.Stop();
 Console.WriteLine("baseline = " + sw.Elapsed);

 sw.Stop();
</code></pre>

--Output :

blocks|key|1296196|text|+.NET+5:+--我将保留前面的答案，因为它仍然与较早的运行时相关，但是.NET+5似乎进一步改进了ConcurrentDictionary，以至于通过TryGetValue()读取的速度实际上比正常的Dictionary都要快，如下面的结果所示(COW是my+CopyOnWriteDictionary，详见下文)。做你想做的事:)|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|1296197|%7C++++++++++Method+%7C++++++++Mean+%7C+++++Error+%7C++++StdDev+%7C++++Gen+0+%7C++++Gen+1+%7C++++Gen+2+%7C+Allocated+%7C
%7C----------------+%7C------------:%7C----------:%7C----------:%7C---------:%7C---------:%7C---------:%7C----------:%7C
%7C+ConcurrentWrite+%7C+1,372.32+us+%7C+12.752+us+%7C+11.304+us+%7C+226.5625+%7C++89.8438+%7C++44.9219+%7C+1398736+B+%7C
%7C++++++++COWWrite+%7C+1,077.39+us+%7C+21.435+us+%7C+31.419+us+%7C++56.6406+%7C++19.5313+%7C++11.7188+%7C++868629+B+%7C
%7C+++++++DictWrite+%7C+++347.19+us+%7C++5.875+us+%7C++5.208+us+%7C+124.5117+%7C+124.5117+%7C+124.5117+%7C++673064+B+%7C
%7C++ConcurrentRead+%7C++++63.53+us+%7C++0.486+us+%7C++0.431+us+%7C++++++++-+%7C++++++++-+%7C++++++++-+%7C+++++++++-+%7C
%7C+++++++++COWRead+%7C++++81.55+us+%7C++0.908+us+%7C++0.805+us+%7C++++++++-+%7C++++++++-+%7C++++++++-+%7C+++++++++-+%7C
%7C++++++++DictRead+%7C++++70.71+us+%7C++0.471+us+%7C++0.393+us+%7C++++++++-+%7C++++++++-+%7C++++++++-+%7C+++++++++-+%7C|code-block|syntax|javascript|1296198|先前的答案，仍然与<+.NET+5:相关|1296199|自从我最初发布这个答案以来，ConcurrentDictionary的最新版本有了很大的改进。它不再锁定读取，因此提供了与我的CopyOnWriteDictionary实现几乎相同的性能配置文件，并提供了更多的功能，因此我建议您在大多数情况下使用它。ConcurrentDictionary的开销仍然比Dictionary或CopyOnWriteDictionary高出20-30%25，因此性能敏感的应用程序仍然可以从它的使用中获益。|1296200|您可以在这里阅读有关我的无锁线程安全复制写字典实现的文章：|1296201|http://www.singulink.com/CodeIndex/post/fastest-thread-safe-lock-free-dictionary|1296202|它目前只是附加(具有替换值的能力)，因为它是作为永久缓存使用的。如果您需要删除，那么我建议使用ConcurrentDictionary，因为将它添加到CopyOnWriteDictionary中将消除由于添加锁定而带来的所有性能提高。|1296203|CopyOnWriteDictionary用于快速写入和查找的速度非常快，通常在没有锁定的情况下以几乎标准的Dictionary速度运行。如果你偶尔写作和经常阅读，这是最快的选择。|1296204|我的实现提供了最大的读取性能，通过消除在正常情况下对任何读取锁的需求，而不对字典进行更新。交换条件是，字典需要在应用更新后被复制和交换(这是在后台线程上完成的)，但是如果您不经常写，或者在初始化期间只写一次，那么交换绝对是值得的。|1296205|entityMap|0|LINK|mutability|MUTABLE|url^0|0|8|1G|K|26|D|2V|A|3P|L|0|0|0|I|0|E|K|1R|L|3H|K|47|A|4I|L|0|0|0|28|0|0|1B|K|23|L|0|0|L|1I|A|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]|$9|19|A|1A|B|D]|$9|1B|A|1C|B|D]|$9|1D|A|1E|B|D]|$9|1F|A|1G|B|D]]|E|@]|F|$]]|$1|G|3|H|5|I|7|1H|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|1I|8|@$9|1J|A|1K|B|C]]|E|@]|F|$]]|$1|N|3|O|5|6|7|1L|8|@$9|1M|A|1N|B|D]|$9|1O|A|1P|B|D]|$9|1Q|A|1R|B|D]|$9|1S|A|1T|B|D]|$9|1U|A|1V|B|D]]|E|@]|F|$]]|$1|P|3|Q|5|6|7|1W|8|@]|E|@]|F|$]]|$1|R|3|S|5|6|7|1X|8|@]|E|@$9|1Y|A|1Z|1|20]]|F|$]]|$1|T|3|U|5|6|7|21|8|@$9|22|A|23|B|D]|$9|24|A|25|B|D]]|E|@]|F|$]]|$1|V|3|W|5|6|7|26|8|@$9|27|A|28|B|D]|$9|29|A|2A|B|D]]|E|@]|F|$]]|$1|X|3|Y|5|6|7|2B|8|@]|E|@]|F|$]]|$1|Z|3|-4|5|6|7|2C|8|@]|E|@]|F|$]]]|10|$11|$5|12|13|14|F|$15|S]]]]

Update for .NET 5: I'll leave the previous answer up as it is still relevant for older runtimes but .NET 5 appears to have further improved <code>ConcurrentDictionary</code> to the point where reads via <code>TryGetValue()</code> are actually faster than even the normal <code>Dictionary</code>, as seen in the results below (COW is my <code>CopyOnWriteDictionary</code>, detailed below). Make what you will of this :)
<pre><code>| Method | Mean | Error | StdDev | Gen 0 | Gen 1 | Gen 2 | Allocated |
|---------------- |------------:|----------:|----------:|---------:|---------:|---------:|----------:|
| ConcurrentWrite | 1,372.32 us | 12.752 us | 11.304 us | 226.5625 | 89.8438 | 44.9219 | 1398736 B |
| COWWrite | 1,077.39 us | 21.435 us | 31.419 us | 56.6406 | 19.5313 | 11.7188 | 868629 B |
| DictWrite | 347.19 us | 5.875 us | 5.208 us | 124.5117 | 124.5117 | 124.5117 | 673064 B |
| ConcurrentRead | 63.53 us | 0.486 us | 0.431 us | - | - | - | - |
| COWRead | 81.55 us | 0.908 us | 0.805 us | - | - | - | - |
| DictRead | 70.71 us | 0.471 us | 0.393 us | - | - | - | - |
</code></pre>
Previous answer, still relevant for &lt; .NET 5:
The latest versions of <code>ConcurrentDictionary</code> have improved significantly since I originally posted this answer. It no longer locks on read and thus offers almost the same performance profile as my <code>CopyOnWriteDictionary</code> implementation with more features so I recommend you use that instead in most cases. <code>ConcurrentDictionary</code> still has 20 - 30% more overhead than <code>Dictionary</code> or <code>CopyOnWriteDictionary</code>, so performance-sensitive applications may still benefit from its use.
You can read about my lock-free thread-safe copy-on-write dictionary implementation here:
<a href="http://www.singulink.com/CodeIndex/post/fastest-thread-safe-lock-free-dictionary" rel="noreferrer">http://www.singulink.com/CodeIndex/post/fastest-thread-safe-lock-free-dictionary</a>
It's currently append-only (with the ability to replace values) as it is intended for use as a permanent cache. If you need removal then I suggest using <code>ConcurrentDictionary</code> since adding that into <code>CopyOnWriteDictionary</code> would eliminate all performance gains due to the added locking.
<code>CopyOnWriteDictionary</code> is very fast for quick bursts of writes and lookups usually run at almost standard <code>Dictionary</code> speed without locking. If you write occasionally and read often, this is the fastest option available.
My implementation provides maximum read performance by removing the need for any read locks under normal circumstances while updates aren't being made to the dictionary. The trade-off is that the dictionary needs to be copied and swapped after updates are applied (which is done on a background thread) but if you don't write often or you only write once during initialization then the trade-off is definitely worth it.

blocks|key|1872770|text|是什么使ConcurrentDictionary<,>在单线程环境中慢得多？|type|blockquote|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1872771|unstyled|1872772|在多线程环境中，机器的开销使其速度更快。|1872773|我的第一反应是lock(){}总是慢一点。但显然不是。|1872774|1872775|lock在没有争议的情况下是非常便宜的。您可以每秒lock一百万次，而您的CPU甚至不会注意到，前提是您是从单个线程执行的。在多线程程序中，破坏性能的是锁的争用。当多个线程为了同一个lock而激烈竞争时，几乎所有线程都必须等待持有锁的幸运线程释放它。这就是ConcurrentDictionary及其粒度锁定实现的亮点所在。并且您拥有的并发性越多(处理器/内核越多)，它就越能发光。|1872776|entityMap^0|4|N|0|0|0|7|8|0|0|0|4|P|4|2J|4|3K|K|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|G|7|T|8|@]|D|@]|E|$]]|$1|H|3|I|5|G|7|U|8|@]|D|@]|E|$]]|$1|J|3|K|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|G|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|G|7|Z|8|@$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]]|D|@]|E|$]]|$1|O|3|-4|5|G|7|18|8|@]|D|@]|E|$]]]|P|$]]

<blockquote>
 What makes <code>ConcurrentDictionary&lt;,&gt;</code> much slower in a single threaded environment? 
</blockquote>

The overhead of the machinery required to make it much faster in multi-threaded environments.

<blockquote>
 My first instinct is that <code>lock(){}</code> will be always slower. but apparently it is not. 
</blockquote>

A <code>lock</code> is very cheap when uncontested. You can <code>lock</code> a million times per second and your CPU won't even notice, provided that you are doing it from a single thread. What kills performance in multi-threaded programs is contention for locks. When multiple threads are competing fiercely for the same <code>lock</code>, almost all of them have to wait for the lucky one that holds the lock to release it. This is where the <code>ConcurrentDictionary</code>, with its granular locking implementation, shines. And the more concurrency you have (the more processors/cores), the more it shines.

blocks|key|1668870|text|在一个线程中使用ConcurrentDictionary或同步访问(如果所有都是在单个线程中完成)是没有意义的。当然，字典会击败ConcrurrentDictionary。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1668871|这在很大程度上取决于线程的使用模式和数量。下面是一个测试，它表明随着线程数量的增加，ConcurrentDictionary的性能优于字典和锁。|1668872|using+System;
using+System.Collections.Concurrent;
using+System.Collections.Generic;
using+System.Diagnostics;
using+System.Threading;

namespace+ConsoleApp
{

++++class+Program
++++{

++++++++static+void+Main(string[]+args)
++++++++{
++++++++++++Run(1,+100000,+10);
++++++++++++Run(10,+100000,+10);
++++++++++++Run(100,+100000,+10);
++++++++++++Run(1000,+100000,+10);
++++++++++++Console.ReadKey();
++++++++}

++++++++static+void+Run(int+threads,+int+count,+int+cycles)
++++++++{
++++++++++++Console.WriteLine("");
++++++++++++Console.WriteLine($"Threads:+{threads},+items:+{count},+cycles:{cycles}");

++++++++++++var+semaphore+=+new+SemaphoreSlim(0,+threads);

++++++++++++var+concurrentDictionary+=+new+ConcurrentDictionary<int,+string>();

++++++++++++for+(int+i+=+0;+i+<+threads;+i%2B%2B)
++++++++++++{
++++++++++++++++Thread+t+=+new+Thread(()+=>+Run(concurrentDictionary,+count,+cycles,++semaphore));
++++++++++++++++t.Start();
++++++++++++}

++++++++++++Thread.Sleep(1000);

++++++++++++var+w+=+Stopwatch.StartNew();

++++++++++++semaphore.Release(threads);

++++++++++++for+(int+i+=+0;+i+<+threads;+i%2B%2B)
++++++++++++++++semaphore.Wait();

++++++++++++Console.WriteLine($"ConcurrentDictionary:+{w.Elapsed}");

++++++++++++var+dictionary+=+new+Dictionary<int,+string>();
++++++++++++for+(int+i+=+0;+i+<+threads;+i%2B%2B)
++++++++++++{
++++++++++++++++Thread+t+=+new+Thread(()+=>+Run(dictionary,+count,+cycles,+semaphore));
++++++++++++++++t.Start();
++++++++++++}

++++++++++++Thread.Sleep(1000);

++++++++++++w.Restart();

++++++++++++semaphore.Release(threads);


++++++++++++for+(int+i+=+0;+i+<+threads;+i%2B%2B)
++++++++++++++++semaphore.Wait();

++++++++++++Console.WriteLine($"Dictionary:+{w.Elapsed}");

++++++++}

++++++++static+void+Run(ConcurrentDictionary<int,+string>+dic,+int+elements,+int+cycles,+SemaphoreSlim+semaphore)
++++++++{
++++++++++++semaphore.Wait();
++++++++++++try
++++++++++++{
++++++++++++++++for+(int+i+=+0;+i+<+cycles;+i%2B%2B)
++++++++++++++++++++for+(int+j+=+0;+j+<+elements;+j%2B%2B)
++++++++++++++++++++{
++++++++++++++++++++++++var+x+=+dic.GetOrAdd(i,+x+=>+x.ToString());
++++++++++++++++++++}
++++++++++++}
++++++++++++finally
++++++++++++{
++++++++++++++++semaphore.Release();
++++++++++++}
++++++++}

++++++++static+void+Run(Dictionary<int,+string>+dic,+int+elements,+int+cycles,+SemaphoreSlim+semaphore)
++++++++{
++++++++++++semaphore.Wait();
++++++++++++try
++++++++++++{
++++++++++++++++for+(int+i+=+0;+i+<+cycles;+i%2B%2B)
++++++++++++++++++++for+(int+j+=+0;+j+<+elements;+j%2B%2B)
++++++++++++++++++++++++lock+(dic)
++++++++++++++++++++++++{
++++++++++++++++++++++++++++if+(!dic.TryGetValue(i,+out+string+value))
++++++++++++++++++++++++++++++++dic[i]+=+i.ToString();
++++++++++++++++++++++++}
++++++++++++}
++++++++++++finally
++++++++++++{
++++++++++++++++semaphore.Release();
++++++++++++}
++++++++}
++++}
}|code-block|syntax|javascript|1668873|线程:+1，条目:+100000，循环:10+ConcurrentDictionary:+00:00:00.0000499字典:+00:00:00.0000137|1668874|线程:+10，条目:+100000，循环:10+ConcurrentDictionary:+00:00:00.0497413字典:+00:00:00.2638265|1668875|线程:+100，条目:+100000，循环:10+ConcurrentDictionary:+00:00:00.2408781字典:+00:00:02.2257736|1668876|线程:+1000，条目:+100000，循环:10+ConcurrentDictionary:+00:00:01.8196668字典:+00:00:25.5717232|1668877|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

There is no point in using ConcurrentDictionary in one thread or synchronizing access if all is done in a single thread. Of course dictionary will beat ConcrurrentDictionary.

Much depends on the usage pattern and number of threads. Here is a test, that shows that ConcurrentDictionary outperforms dictionary and lock with thread number increase. 

<pre><code>using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;

namespace ConsoleApp
{

 class Program
 {

 static void Main(string[] args)
 {
 Run(1, 100000, 10);
 Run(10, 100000, 10);
 Run(100, 100000, 10);
 Run(1000, 100000, 10);
 Console.ReadKey();
 }

 static void Run(int threads, int count, int cycles)
 {
 Console.WriteLine("");
 Console.WriteLine($"Threads: {threads}, items: {count}, cycles:{cycles}");

 var semaphore = new SemaphoreSlim(0, threads);

 var concurrentDictionary = new ConcurrentDictionary&lt;int, string&gt;();

 for (int i = 0; i &lt; threads; i++)
 {
 Thread t = new Thread(() =&gt; Run(concurrentDictionary, count, cycles, semaphore));
 t.Start();
 }

 Thread.Sleep(1000);

 var w = Stopwatch.StartNew();

 semaphore.Release(threads);

 for (int i = 0; i &lt; threads; i++)
 semaphore.Wait();

 Console.WriteLine($"ConcurrentDictionary: {w.Elapsed}");

 var dictionary = new Dictionary&lt;int, string&gt;();
 for (int i = 0; i &lt; threads; i++)
 {
 Thread t = new Thread(() =&gt; Run(dictionary, count, cycles, semaphore));
 t.Start();
 }

 Thread.Sleep(1000);

 w.Restart();

 semaphore.Release(threads);


 for (int i = 0; i &lt; threads; i++)
 semaphore.Wait();

 Console.WriteLine($"Dictionary: {w.Elapsed}");

 }

 static void Run(ConcurrentDictionary&lt;int, string&gt; dic, int elements, int cycles, SemaphoreSlim semaphore)
 {
 semaphore.Wait();
 try
 {
 for (int i = 0; i &lt; cycles; i++)
 for (int j = 0; j &lt; elements; j++)
 {
 var x = dic.GetOrAdd(i, x =&gt; x.ToString());
 }
 }
 finally
 {
 semaphore.Release();
 }
 }

 static void Run(Dictionary&lt;int, string&gt; dic, int elements, int cycles, SemaphoreSlim semaphore)
 {
 semaphore.Wait();
 try
 {
 for (int i = 0; i &lt; cycles; i++)
 for (int j = 0; j &lt; elements; j++)
 lock (dic)
 {
 if (!dic.TryGetValue(i, out string value))
 dic[i] = i.ToString();
 }
 }
 finally
 {
 semaphore.Release();
 }
 }
 }
}
</code></pre>

Threads: 1, items: 100000, cycles:10
ConcurrentDictionary: 00:00:00.0000499
Dictionary: 00:00:00.0000137

Threads: 10, items: 100000, cycles:10
ConcurrentDictionary: 00:00:00.0497413
Dictionary: 00:00:00.2638265

Threads: 100, items: 100000, cycles:10
ConcurrentDictionary: 00:00:00.2408781
Dictionary: 00:00:02.2257736

Threads: 1000, items: 100000, cycles:10
ConcurrentDictionary: 00:00:01.8196668
Dictionary: 00:00:25.5717232

blocks|key|1668922|text|在.Net+4中，ConcurrentDictionary使用了非常糟糕的锁管理和争用解决方案，这使得它非常慢。具有自定义锁定和/或TestAndSet使用的字典，整个字典速度更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1668923|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

In .Net 4, ConcurrentDictionary utilized very poor locking management and contention resolution that made it extremely slow. Dictionary with custom locking and/or even TestAndSet usage to COW the whole dictionary was faster.

Related brief info: 

AFAIK , The concurrent stack, queue, and bag classes are implemented internally with linked lists. 
And I know that there is much less contention because each thread is responsible for its own linked list.
Any way , my question is about the <code>ConcurrentDictionary&lt;,&gt;</code>

But I was testing this code :(single thread)

<pre><code>Stopwatch sw = new Stopwatch();
sw.Start();

 var d = new ConcurrentDictionary &lt; int, int &gt; ();
 for(int i = 0; i &lt; 1000000; i++) d[i] = 123;
 for(int i = 1000000; i &lt; 2000000; i++) d[i] = 123;
 for(int i = 2000000; i &lt; 3000000; i++) d[i] = 123;
 Console.WriteLine("baseline = " + sw.Elapsed);

sw.Restart();

 var d2 = new Dictionary &lt; int, int &gt; ();
 for(int i = 0; i &lt; 1000000; i++) lock (d2) d2[i] = 123;
 for(int i = 1000000; i &lt; 2000000; i++) lock (d2) d2[i] = 123;
 for(int i = 2000000; i &lt; 3000000; i++) lock (d2) d2[i] = 123;
 Console.WriteLine("baseline = " + sw.Elapsed);

sw.Stop();
</code></pre>

Result : (tested many times, same values (+/-)).

<pre><code>baseline = 00:00:01.2604656
baseline = 00:00:00.3229741
</code></pre>

Question : 

What makes <code>ConcurrentDictionary&lt;,&gt;</code> much slower in a single threaded environment ?

My first instinct is that <code>lock(){}</code> will be always slower. but apparently it is not.

ConcurrentDictionary<> performance at a single thread misunderstanding?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

相关简要信息：AFAIK、并发堆栈、队列和包类是在内部使用链接列表实现的。我知道争用少得多，因为每个线程都负责自己的链接列表。不管怎样，我的问题是关于ConcurrentDictionary<,>的但是我正在测试这个代码：(单线程)Stopwatch sw = new Stopwatch();sw.Start(); ...

问ConcurrentDictionary<>性能在单线程误解？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问ConcurrentDictionary<>性能在单线程误解？EN