你不了解的Dictionary和ConcurrentDictionary

最近在做项目时，多线程中使用Dictionary的全局变量时，发现数据并没有存入到Dictionary中，但是程序也没有报错，经过自己的一番排查，发现Dictionary为非线程安全类型，因此我感觉数据没有写进去的原因是多线程在争夺全局变量时，导致数据未写入，于是去对Dictionary进行仔细的了解。
经过在网上查阅资料，发现大家讲解最多的是Dictionary(非线程安全)和ConcurrentDictionary(线程安全)，于是我也从这两个关键字来仔细的讲解，顺便也更加深入的认识它们。
Dictionary怎样解决线程安全问题？可以使用加锁、线程全局变量、使用ConcurrentDictionary等。下面我们就一起来看看吧，Let’s go。

Dictionary

Dictionary泛型类提供了键值对映射，通过TKey来检索值的速度非常快，时间复杂度接近与O(1)，是因为Dictionary通过哈希表实现，是一种变相的HashTable，采用分离链接散列表的数据结构解决哈希冲突问题。
在早期的C#版本中，可以将集合初始值设定项用于序列样式集合，包括在键值对周围添加括号而得到Dictionary，如：

Dictionary<int, string> msgs = new Dictionary<int, string>()
{
    { 1, "Hello, "},
    { 2 , "World"},
    { 3, "!"}
};

而新的语法支持使用索引分配到集合中，如：

Dictionary<int, string> MsgErrs = new Dictionary<int, string>()
{
    [1] = "Hello, ",
    [2] = "World",
    [3] = "!",
};

上述两者在初始化赋值时都差不多，但是两者还是有一些区别，前者在初始化时出现重复key值，程序会直接报错。而后者初始化时，key可以有重复值，系统会自动过滤掉重复的key值，程序也不会报错。
实现键/值对集合
每次对字典的添加都包含一个值与其关联的值，通过使用键来检索十分方便；
如果使用集合初始值设定项生成Dictionary集合，可以使用如下方法：

public static Dictionary<string, Element> BuildDic()
        {
 return new Dictionary<string, Element>
            {
                {"L", new Element(){Symbol = "L", Name = "Postass", AutominNumber = 9}},
                {"Q", new Element(){ Symbol = "Q", Name = "Calcium", AutominNumber = 99}},
                {"M", new Element(){ Symbol = "JY", Name = "JYaoiang", AutominNumber=7924}}
            };
        }

Dictionary添加值

public static void IterateDictionary()
        {
            Dictionary<string, Element> element = BuildDic();
 foreach(KeyValuePair<string, Element> keyValue in element)
            {
                Element ele = keyValue.Value;
                Console.WriteLine(string.Format("Key={0}; Values={0};{1};{2}", keyValue.Key, ele.Symbol, ele.Name, ele.AutominNumber));
            }
        }
 public static Dictionary<string, Element> BuildDictionary()
        {
 var elements = new Dictionary<string, Element>();
            AddDictionary(elements, "L", "LLL", 9);
            AddDictionary(elements, "J", "LJLHHH", 19);
            AddDictionary(elements, "A", "ABABABA", 20);
 return elements;
        }
 public static void AddDictionary(Dictionary<string, Element> elements, string symbol, string name, int num)
        {
            Element ele = new Element()
            {
                Symbol = symbol,
                Name = name,
                AutominNumber = num
            };
            elements.Add(key: symbol, value: ele);
        }

ContainsKey方法和Item[]属性

public static void FindDictionary(string symbol)
        {
            Dictionary<string, Element> elements = BuildDictionary();
 if (elements.ContainsKey(symbol))
            {
                Element ele = elements[symbol];
                Console.WriteLine("Found: " + ele.Name);
            }
 else
            {
                Console.WriteLine("Not found " + symbol);
            }
        }

TryGetValue方法

public static void FindDictionaryOfTryGetValue(string symbol)
        {
            Dictionary<string, Element> elements = BuildDictionary();
            Element ele = null;
 if(elements.TryGetValue(symbol, out ele))
            {
                Console.WriteLine("Found: " + ele.Name);
            }
 else
            {
                Console.WriteLine("Not found " + symbol);
            }
        }

在这里讲解了Dictionary的常见使用方法，这里在啰嗦一句，不知道大家在使用Dictionary时有没有注意带Add方法和TryAdd方法，这两个方法到底有什么区别？
我们都知道，在往Dictionary中添加键值时，键是不能重复的，如果使用Add方法添加重复的key，会使程序报错。要想避免这个问题，则可以使用TryAdd方法，当添加重复键值使，该方法会返回false，就可以避免此类问题。

ConcurrentDictionary

在.NET Framework 4以及更新的版本中，System.Collections.Concurrent命名空间中的集合可提供高效的线程安全操作，以便从多个线程访问集合项。
当有多个线程访问集合项时，应该使用System.Collections.Concurrent命名空间中的类，而不是使用System.Collections.Generic和System.Collections命名空间中的类。
System.Collections.Concurrent命名空间中的类：BlockingCollection、ConcurrentDictionary、ConcurrentQueue、ConcurrentStack。
System.Collections命名空间中的类不会将元素作为特别类型化的对象存储，而是作为object类型的对象存储。
ConcurrentDictionary用法与Dictionary类似，这里就不再详细讲解了。但是ConcurrentDictionary只能使用TryAdd方法，而Dictionary可以使用Add和TryAdd方法。

Dictionary和ConcurrentDictionary多线程

带大家认识完Dictionary和ConcurrentDictionary，下面就回归主题，看看两者在多线程方面的使用情况。
代码如下：

ConcurrentDictionary<int, string> keys = new ConcurrentDictionary<int, string>();
keys.TryAdd(1, "LL");
keys.TryAdd(2, "LL");
Dictionary<int, string> dic = new Dictionary<int, string>();
dic.Add(1, "OJ");
dic.TryAdd(2, "R");
Stopwatch stopwatch = new Stopwatch();
#region 写入
stopwatch.Start();
Parallel.For(0, 10000000, i =>
{
 lock (dic)
    {
        dic[i] = new Random().Next(100, 99999).ToString();
    }
});
stopwatch.Stop();
Console.WriteLine("Dictionary加锁写入花费时间：{0}", stopwatch.Elapsed);
stopwatch.Restart();
Parallel.For(0, 10000000, i =>
{
    keys[i] = new Random().Next(100, 99999).ToString();
});
stopwatch.Stop();
Console.WriteLine("ConcurrentDictionary加锁写入花费时间：{0}", stopwatch.Elapsed);
#endregion
#region 读取
string result = string.Empty;
stopwatch.Restart();
Parallel.For(0, 10000000, i =>
{
 lock (dic)
    {
        result = dic[i];
    }
});
stopwatch.Stop();
Console.WriteLine("Dictionary加锁读取花费时间：{0}", stopwatch.Elapsed);
stopwatch.Restart();
Parallel.For(0, 10000000, i =>
{
    result = keys[i];
});
stopwatch.Stop();
Console.WriteLine("ConcurrentDictionary加锁读取花费时间：{0}", stopwatch.Elapsed);
#endregion
Console.ReadLine();

可以发现，在多线程下，加了lock的Dictionary写入性能要比ConconcurrentDictionary的写入性能更好，读取数据ConcurrentDictionary性能更好。
当我们将写入的数据增加到20000000时，ConcurrentDictionary写入性能明显就比Dictionary性能差了，但是读取性能ConcurrentDictionary更好。
​

当我们将写入的数据增加到2000000时，ConcurrentDictionary写入性能还是比Dictionary性能差，但是读取性能ConcurrentDictionary更好。
​

综上，经过对两者的比较，ConcurrentDictionary读取性能更好，Dictionary写入性能更好。
至于，具体是什么原因，到时候我会进行深入讲解，这篇文章大致就讲到这里了，我们下篇文章见。