目录

• 浅析c# dictionary实现原理
  • • 1、hash算法
    • 2、hash桶算法
  • 三、dictionary实现
    • 1. entry结构体
    • 3. dictionary - add操作
    • 4. dictionary - find操作
    • 5. dictionary - remove操作
    • 6. dictionary - resize操作(扩容)
    • 7. dictionary - 再谈add操作
    • 8. collection版本控制

浅析c# dictionary实现原理

一、前言

本篇文章配图以及文字其实整理出来很久了，但是由于各种各样的原因推迟到现在才发出来，还有之前立flag的《多线程编程》的笔记也都已经写好了，只是说还比较糙，需要找个时间整理一下才能和大家见面。

对于c#中的dictionary类相信大家都不陌生，这是一个collection(集合)类型，可以通过key/value(键值对的形式来存放数据；该类最大的优点就是它查找元素的时间复杂度接近o(1)，实际项目中常被用来做一些数据的本地缓存，提升整体效率。

那么是什么样的设计能使得dictionary类能实现o(1)的时间复杂度呢？那就是本篇文章想和大家讨论的东西；这些都是个人的一些理解和观点，如有表述不清楚、错误之处，请大家批评指正，共同进步。

二、理论知识

对于dictionary的实现原理，其中有两个关键的算法，一个是hash算法，一个是用于应对hash碰撞冲突解决算法。

1、hash算法

hash算法是一种数字摘要算法，它能将不定长度的二进制数据集给映射到一个较短的二进制长度数据集，常见的md5算法就是一种hash算法，通过md5算法可对任何数据生成数字摘要。而实现了hash算法的函数我们叫她hash函数。hash函数有以下几点特征。

1. 相同的数据进行hash运算，得到的结果一定相同。hashfunc(key1) == hashfunc(key1)
2. 不同的数据进行hash运算，其结果也可能会相同，(hash会产生碰撞)。key1 != key2 => hashfunc(key1) == hashfunc(key2).
3. hash运算时不可逆的，不能由key获取原始的数据。key1 => hashcode但是hashcode =\=> key1。

下图就是hash函数的一个简单说明，任意长度的数据通过hashfunc映射到一个较短的数据集中。

关于hash碰撞下图很清晰的就解释了，可从图中得知sandra dee 和 john smith通过hash运算后都落到了02的位置，产生了碰撞和冲突。

常见的构造hash函数的算法有以下几种。

1. 直接寻址法：取keyword或keyword的某个线性函数值为散列地址。即h(key)=key或h(key) = a•key + b，当中a和b为常数（这样的散列函数叫做自身函数）

2. 数字分析法：分析一组数据，比方一组员工的出生年月日，这时我们发现出生年月日的前几位数字大体同样，这种话，出现冲突的几率就会非常大，可是我们发现年月日的后几位表示月份和详细日期的数字区别非常大，假设用后面的数字来构成散列地址，则冲突的几率会明显减少。因此数字分析法就是找出数字的规律，尽可能利用这些数据来构造冲突几率较低的散列地址。

3. 平方取中法：取keyword平方后的中间几位作为散列地址。

4. 折叠法：将keyword切割成位数同样的几部分，最后一部分位数能够不同，然后取这几部分的叠加和（去除进位）作为散列地址。

5. 随机数法：选择一随机函数，取keyword的随机值作为散列地址，通经常使用于keyword长度不同的场合。

6. 除留余数法：取keyword被某个不大于散列表表长m的数p除后所得的余数为散列地址。即 h(key) = key mod p, p<=m。不仅能够对keyword直接取模，也可在折叠、平方取中等运算之后取模。对p的选择非常重要，一般取素数或m，若p选的不好，容易产生碰撞.

2、hash桶算法

说到hash算法大家就会想到hash表，一个key通过hash函数运算后可快速的得到hashcode，通过hashcode的映射可直接get到value，但是hashcode一般取值都是非常大的，经常是2^32以上，不可能对每个hashcode都指定一个映射。

因为这样的一个问题，所以人们就将生成的hashcode以分段的形式来映射，把每一段称之为一个bucket（桶），一般常见的hash桶就是直接对结果取余。

假设将生成的hashcode可能取值有2^32个，然后将其切分成一段一段，使用8个桶来映射，那么就可以通过bucketindex = hashfunc(key1) % 8这样一个算法来确定这个hashcode映射到具体的哪个桶中。

大家可以看出来，通过hash桶这种形式来进行映射，所以会加剧hash的冲突。

3、解决冲突算法

对于一个hash算法，不可避免的会产生冲突，那么产生冲突以后如何处理，是一个很关键的地方，目前常见的冲突解决算法有拉链法(dictionary实现采用的)、开放定址法、再hash法、公共溢出分区法，本文只介绍拉链法与再hash法，对于其它算法感兴趣的同学可参考文章最后的参考文献。

1. 拉链法：这种方法的思路是将产生冲突的元素建立一个单链表，并将头指针地址存储至hash表对应桶的位置。这样定位到hash表桶的位置后可通过遍历单链表的形式来查找元素。

2. 再hash法：顾名思义就是将key使用其它的hash函数再次hash，直到找到不冲突的位置为止。

对于拉链法有一张图来描述，通过在冲突位置建立单链表，来解决冲突。

三、dictionary实现

dictionary实现我们主要对照源码来解析，目前对照源码的版本是.net framwork 4.7。地址可戳一戳这个链接 源码地址：link

这一章节中主要介绍dictionary中几个比较关键的类和对象，然后跟着代码来走一遍插入、删除和扩容的流程，相信大家就能理解它的设计原理。

1. entry结构体

首先我们引入entry这样一个结构体，它的定义如下代码所示。这是dictionary种存放数据的最小单位，调用add(key,value)方法添加的元素都会被封装在这样的一个结构体中。

private struct entry {
    public int hashcode;    // 除符号位以外的31位hashcode值, 如果该entry没有被使用，那么为-1
    public int next;        // 下一个元素的下标索引，如果没有下一个就为-1
    public tkey key;        // 存放元素的键
    public tvalue value;    // 存放元素的值
}

2. 其它关键私有变量

除了entry结构体外，还有几个关键的私有变量，其定义和解释如下代码所示。

private int[] buckets;      // hash桶
private entry[] entries;    // entry数组，存放元素
private int count;          // 当前entries的index位置
private int version;        // 当前版本，防止迭代过程中集合被更改
private int freelist;       // 被删除entry在entries中的下标index，这个位置是空闲的
private int freecount;      // 有多少个被删除的entry，有多少个空闲的位置
private iequalitycomparer<tkey> comparer;   // 比较器
private keycollection keys;     // 存放key的集合
private valuecollection values;     // 存放value的集合

上面代码中，需要注意的是buckets、entries这两个数组，这是实现dictionary的关键。

3. dictionary - add操作

经过上面的分析，相信大家还不是特别明白为什么需要这么设计，需要这么做。那我们现在来走一遍dictionary的add流程，来体会一下。

首先我们用图的形式来描述一个dictionary的数据结构，其中只画出了关键的地方。桶大小为4以及entry大小也为4的一个数据结构。

然后我们假设需要执行一个add操作，dictionary.add("a","b")，其中key = "a",value = "b"。

1. 根据key的值，计算出它的hashcode。我们假设"a"的hash值为6（gethashcode("a") = 6）。

2. 通过对hashcode取余运算，计算出该hashcode落在哪一个buckets桶中。现在桶的长度（buckets.length）为4，那么就是6 % 4最后落在index为2的桶中，也就是buckets[2]。

3. 避开一种其它情况不谈，接下来它会将hashcode、key、value等信息存入entries[count]中，因为count位置是空闲的；继续count++指向下一个空闲位置。上图中第一个位置，index=0就是空闲的，所以就存放在entries[0]的位置。

4. 将entry的下标entryindex赋值给buckets中对应下标的bucket。步骤3中是存放在entries[0]的位置，所以buckets[2]=0。

5. 最后version++，集合发生了变化，所以版本需要+1。只有增加、替换和删除元素才会更新版本

   上文中的步骤1~5只是方便大家理解，实际上有一些偏差，后文再谈add操作小节中会补充。

完成上面add操作后，数据结构更新成了下图这样的形式。

这样是理想情况下的操作，一个bucket中只有一个hashcode没有碰撞的产生，但是实际上是会经常产生碰撞；那么dictionary类中又是如何解决碰撞的呢。

我们继续执行一个add操作，dictionary.add("c","d")，假设gethashcode(“c”)=6，最后6 % 4 = 2。最后桶的index也是2，按照之前的步骤1~3是没有问题的，执行完后数据结构如下图所示。

如果继续执行步骤4那么buckets[2] = 1，然后原来的buckets[2]=>entries[0]的关系就会丢失，这是我们不愿意看到的。现在entry中的next就发挥大作用了。

如果对应的buckets[index]有其它元素已经存在，那么会执行以下两条语句，让新的entry.next指向之前的元素，让buckets[index]指向现在的新的元素，就构成了一个单链表。

entries[index].next = buckets[targetbucket];
...
buckets[targetbucket] = index;

实际上步骤4也就是做一个这样的操作，并不会去判断是不是有其它元素，因为buckets中桶初始值就是-1，不会造成问题。

经过上面的步骤以后，数据结构就更新成了下图这个样子。

4. dictionary - find操作

为了方便演示如何查找，我们继续add一个元素dictionary.add("e","f")，gethashcode(“e”) = 7; 7% buckets.length=3,数据结构如下所示。

假设我们现在执行这样一条语句dictionary.getvalueordefault("a")，会执行以下步骤.

1. 获取key的hashcode，计算出所在的桶位置。我们之前提到，"a"的hashcode=6，所以最后计算出来targetbucket=2。
2. 通过buckets[2]=1找到entries[1],比较key的值是否相等，相等就返回entryindex，不想等就继续entries[next]查找，直到找到key相等元素或者next == -1的时候。这里我们找到了key == "a"的元素，返回entryindex=0。
3. 如果entryindex >= 0那么返回对应的entries[entryindex]元素，否则返回default(tvalue)。这里我们直接返回entries[0].value。

整个查找的过程如下图所示.

将查找的代码摘录下来，如下所示。

// 寻找entry元素的位置
private int findentry(tkey key) {
    if( key == null) {
        throwhelper.throwargumentnullexception(exceptionargument.key);
    }

    if (buckets != null) {
        int hashcode = comparer.gethashcode(key) & 0x7fffffff; // 获取hashcode，忽略符号位
        // int i = buckets[hashcode % buckets.length] 找到对应桶，然后获取entry在entries中位置
        // i >= 0; i = entries[i].next 遍历单链表
        for (int i = buckets[hashcode % buckets.length]; i >= 0; i = entries[i].next) {
            // 找到就返回了
            if (entries[i].hashcode == hashcode && comparer.equals(entries[i].key, key)) return i;
        }
    }
    return -1;
}
...
internal tvalue getvalueordefault(tkey key) {
    int i = findentry(key);
    // 大于等于0代表找到了元素位置，直接返回value
    // 否则返回该类型的默认值
    if (i >= 0) {
        return entries[i].value;
    }
    return default(tvalue);
}

5. dictionary - remove操作

前面已经向大家介绍了增加、查找，接下来向大家介绍dictionary如何执行删除操作。我们沿用之前的dictionary数据结构。

删除前面步骤和查找类似，也是需要找到元素的位置，然后再进行删除的操作。

我们现在执行这样一条语句dictionary.remove("a")，hashfunc运算结果和上文中一致。步骤大部分与查找类似，我们直接看摘录的代码，如下所示。

public bool remove(tkey key) {
    if(key == null) {
        throwhelper.throwargumentnullexception(exceptionargument.key);
    }

    if (buckets != null) {
        // 1. 通过key获取hashcode
        int hashcode = comparer.gethashcode(key) & 0x7fffffff;
        // 2. 取余获取bucket位置
        int bucket = hashcode % buckets.length;
        // last用于确定是否当前bucket的单链表中最后一个元素
        int last = -1;
        // 3. 遍历bucket对应的单链表
        for (int i = buckets[bucket]; i >= 0; last = i, i = entries[i].next) {
            if (entries[i].hashcode == hashcode && comparer.equals(entries[i].key, key)) {
                // 4. 找到元素后，如果last< 0，代表当前是bucket中最后一个元素，那么直接让bucket内下标赋值为 entries[i].next即可
                if (last < 0) {
                    buckets[bucket] = entries[i].next;
                }
                else {
                    // 4.1 last不小于0，代表当前元素处于bucket单链表中间位置，需要将该元素的头结点和尾节点相连起来,防止链表中断
                    entries[last].next = entries[i].next;
                }
                // 5. 将entry结构体内数据初始化
                entries[i].hashcode = -1;
                // 5.1 建立freelist单链表
                entries[i].next = freelist;
                entries[i].key = default(tkey);
                entries[i].value = default(tvalue);
                // *6. 关键的代码，freelist等于当前的entry位置，下一次add元素会优先add到该位置
                freelist = i;
                freecount++;
                // 7. 版本号+1
                version++;
                return true;
            }
        }
    }
    return false;
}

执行完上面代码后，数据结构就更新成了下图所示。需要注意varsion、freelist、freecount的值都被更新了。

6. dictionary - resize操作(扩容)

有细心的小伙伴可能看过了add操作以后就想问了，buckets、entries不就是两个数组么，那万一数组放满了怎么办？接下来就是我所要介绍的resize（扩容）这样一种操作，对我们的buckets、entries进行扩容。

6.1 扩容操作的触发条件

首先我们需要知道在什么情况下，会发生扩容操作；第一种情况自然就是数组已经满了，没有办法继续存放新的元素。如下图所示的情况。

从上文中大家都知道，hash运算会不可避免的产生冲突，dictionary中使用拉链法来解决冲突的问题，但是大家看下图中的这种情况。

所有的元素都刚好落在buckets[3]上面，结果就是导致了时间复杂度o(n)，查找性能会下降；所以第二种，dictionary中发生的碰撞次数太多，会严重影响性能，也会触发扩容操作。

目前.net framwork 4.7中设置的碰撞次数阈值为100.

public const int hashcollisionthreshold = 100;

6.2 扩容操作如何进行

为了给大家演示的清楚，模拟了以下这种数据结构，大小为2的dictionary，假设碰撞的阈值为2；现在触发hash碰撞扩容。

开始扩容操作。

1.申请两倍于现在大小的buckets、entries
2.将现有的元素拷贝到新的entries

完成上面两步操作后，新数据结构如下所示。

3、如果是hash碰撞扩容，使用新hashcode函数重新计算hash值

上文提到了，这是发生了hash碰撞扩容，所以需要使用新的hash函数计算hash值。新的hash函数并一定能解决碰撞的问题，有可能会更糟，像下图中一样的还是会落在同一个bucket上。

4、对entries每个元素bucket = newentries[i].hashcode % newsize确定新buckets位置

5、重建hash链，newentries[i].next=buckets[bucket]; buckets[bucket]=i;

因为buckets也扩充为两倍大小了，所以需要重新确定hashcode在哪个bucket中；最后重新建立hash单链表.

这就完成了扩容的操作，如果是达到hash碰撞阈值触发的扩容可能扩容后结果会更差。

在jdk中，hashmap如果碰撞的次数太多了，那么会将单链表转换为红黑树提升查找性能。目前.net framwork中还没有这样的优化，.net core中已经有了类似的优化，以后有时间在分享.net core的一些集合实现。

每次扩容操作都需要遍历所有元素，会影响性能。所以创建dictionary实例时最好设置一个预估的初始大小。

private void resize(int newsize, bool forcenewhashcodes) {
    contract.assert(newsize >= entries.length);
    // 1. 申请新的buckets和entries
    int[] newbuckets = new int[newsize];
    for (int i = 0; i < newbuckets.length; i++) newbuckets[i] = -1;
    entry[] newentries = new entry[newsize];
    // 2. 将entries内元素拷贝到新的entries总
    array.copy(entries, 0, newentries, 0, count);
    // 3. 如果是hash碰撞扩容，使用新hashcode函数重新计算hash值
    if(forcenewhashcodes) {
        for (int i = 0; i < count; i++) {
            if(newentries[i].hashcode != -1) {
                newentries[i].hashcode = (comparer.gethashcode(newentries[i].key) & 0x7fffffff);
            }
        }
    }
    // 4. 确定新的bucket位置
    // 5. 重建hahs单链表
    for (int i = 0; i < count; i++) {
        if (newentries[i].hashcode >= 0) {
            int bucket = newentries[i].hashcode % newsize;
            newentries[i].next = newbuckets[bucket];
            newbuckets[bucket] = i;
        }
    }
    buckets = newbuckets;
    entries = newentries;
}

7. dictionary - 再谈add操作

在我们之前的add操作步骤中，提到了这样一段话，这里提到会有一种其它的情况，那就是有元素被删除的情况。

1. 避开一种其它情况不谈，接下来它会将hashcode、key、value等信息存入entries[count]中，因为count位置是空闲的；继续count++指向下一个空闲位置。上图中第一个位置，index=0就是空闲的，所以就存放在entries[0]的位置。

因为count是通过自增的方式来指向entries[]下一个空闲的entry，如果有元素被删除了，那么在count之前的位置就会出现一个空闲的entry；如果不处理，会有很多空间被浪费。

这就是为什么remove操作会记录freelist、freecount，就是为了将删除的空间利用起来。实际上add操作会优先使用freelist的空闲entry位置，摘录代码如下。

private void insert(tkey key, tvalue value, bool add){
    
    if( key == null ) {
        throwhelper.throwargumentnullexception(exceptionargument.key);
    }

    if (buckets == null) initialize(0);
    // 通过key获取hashcode
    int hashcode = comparer.gethashcode(key) & 0x7fffffff;
    // 计算出目标bucket下标
    int targetbucket = hashcode % buckets.length;
    // 碰撞次数
    int collisioncount = 0;
    for (int i = buckets[targetbucket]; i >= 0; i = entries[i].next) {
        if (entries[i].hashcode == hashcode && comparer.equals(entries[i].key, key)) {
            // 如果是增加操作，遍历到了相同的元素，那么抛出异常
            if (add) {      
                throwhelper.throwargumentexception(exceptionresource.argument_addingduplicate);
            }
            // 如果不是增加操作，那可能是索引赋值操作 dictionary["foo"] = "foo"
            // 那么赋值后版本++，退出
            entries[i].value = value;
            version++;
            return;
        }
        // 每遍历一个元素，都是一次碰撞
        collisioncount++;
    }
    int index;
    // 如果有被删除的元素，那么将元素放到被删除元素的空闲位置
    if (freecount > 0) {
        index = freelist;
        freelist = entries[index].next;
        freecount--;
    }
    else {
        // 如果当前entries已满，那么触发扩容
        if (count == entries.length)
        {
            resize();
            targetbucket = hashcode % buckets.length;
        }
        index = count;
        count++;
    }

    // 给entry赋值
    entries[index].hashcode = hashcode;
    entries[index].next = buckets[targetbucket];
    entries[index].key = key;
    entries[index].value = value;
    buckets[targetbucket] = index;
    // 版本号++
    version++;

    // 如果碰撞次数大于设置的最大碰撞次数，那么触发hash碰撞扩容
    if(collisioncount > hashhelpers.hashcollisionthreshold && hashhelpers.iswellknownequalitycomparer(comparer)) 
    {
        comparer = (iequalitycomparer<tkey>) hashhelpers.getrandomizedequalitycomparer(comparer);
        resize(entries.length, true);
    }
}

上面就是完整的add代码，还是很简单的对不对？

8. collection版本控制

在上文中一直提到了version这个变量，在每一次新增、修改和删除操作时，都会使version++；那么这个version存在的意义是什么呢？

首先我们来看一段代码，这段代码中首先实例化了一个dictionary实例，然后通过foreach遍历该实例，在foreach代码块中使用dic.remove(kv.key)删除元素。

结果就是抛出了system.invalidoperationexception:"collection was modified..."这样的异常，迭代过程中不允许集合出现变化。如果在java中遍历直接删除元素，会出现诡异的问题，所以.net中就使用了version来实现版本控制。

那么如何在迭代过程中实现版本控制的呢？我们看一看源码就很清楚的知道。

在迭代器初始化时，就会记录dictionary.version版本号，之后每一次迭代过程都会检查版本号是否一致，如果不一致将抛出异常。

这样就避免了在迭代过程中修改了集合，造成很多诡异的问题。

四、参考文献及总结

本文在编写过程中，主要参考了以下文献，在此感谢其作者在知识分享上作出的贡献！

2. https://en.wikipedia.org/wiki/hash_table

笔者水平有限，如果错误欢迎各位批评指正！