ConcurrentDictionary实现

.Net4 增加的System.Collection.Concurrent线程安全的集合实现，这儿有MS的性能测试报告：Thread-safe Collections in .NET Framework 4 and Their Performance Characteristics。总的来说效率还是很不错的，为了提高效率用了一些技巧，接口上也多是TryXXX。

         ConcurrentDictionary采用Level-Lock方式，和Dictionary一样还是只有一个buckets，只是内部lock时，采用locknum=key.GetHashcode%lockCount, lock(objects[num]),方式，默认情况下DefaultConcurrencyLevel=4 * Environment.ProcessorCount;  也就是4*CPU核心数。相比于一个lock object，在高并发使用多个lock object可以很大减少lock等待的可能；但在整个集合操作（如：Count,Clear,Expend..）还是需要全部加锁后操作。

         为啥接口都变成TryXXX呢：因为如Add 和Remove之间存在竞争，不能再像单线程集合那样简单的抛出异常，不能抛出异常那就得要一个是否操作成功的返回码~

 

下面是节点数据结构，算法也有很大的区别，这里使用类，hashtable ,Dictionary都用的是struct。问题在于如果使用HashTable双hash算法，对同一个数组就没法做Level啦。Dictionary分别两个数组Bluckets和Entitys，同样无法区分level。至于hash算法比起前两者都要简单不少呢。所以采用了class 可以使用m_next连接方式解决冲突,m_ext 使用volatile可解决多线程缓存同步问题。

来咱来计算一下内存占用问题吧使用class方式无疑对于简单字段要占用多不少内存，就拿int-int来算：

  Dictionary 4*5=20字节/node

ConcurrentDictionary 在x64下：8+4+4+4+8+8+8=42字节/node 要多占不少内存那。不过对于Node=null时，空位多的时候也能节省部分内存，不过一般空位多了不应该~

------  blucket（8）+Node（key（4）+value（4）+hash（4）+next（8）+methodRef(8))+syncblk(8)）

*有个想法咱吧Dictionary改造一下位Level Lock，用多个Dict，前面文章有测试效果，还不错。

private class Node //不再是struck 了呢
{
    internal TKey m_key;
    internal TValue m_value;
    internal volatile Node m_next;  //在这儿volatile很重要
    internal int m_hashcode;
    internal node()
    {
        this.m_key = key;
        this.m_value = value;
        this.m_next = next;
        this.m_hashcode = hashcode;
    }
}


下面是Add的实现：

private bool TryAddInternal(TKey key, TValue value, bool updateIfExists, bool acquireLock, out TValue resultingValue)
{
    int hashCode = this.m_comparer.GetHashCode(key);
    checked
    {
        ConcurrentDictionary<TKey, TValue>.Node[] buckets;
        bool flag;
        while (true)
        {
            buckets = this.m_buckets;
            int num;
            int num2;
            this.GetBucketAndLockNo(hashCode, out num, out num2, buckets.Length);//计算Hash地址和新的节点落在那个Lock上面
            flag = false;
            bool flag2 = false;
            try
            {
                if (acquireLock)
                {
                    Monitor.Enter(this.m_locks[num2], ref flag2);
                }
                if (buckets != this.m_buckets)
                {
                    continue; //这儿很重要Enter之前如果不做这个判断，可能因为字段扩容而丢失值
                }
                ConcurrentDictionary<TKey, TValue>.Node node = null;
                for (ConcurrentDictionary<TKey, TValue>.Node node2 = buckets[num]; node2 != null; node2 = node2.m_next)
                {
                    if (this.m_comparer.Equals(node2.m_key, key))
                    {
                        if (updateIfExists)
                        {
                            ConcurrentDictionary<TKey, TValue>.Node node3 = new ConcurrentDictionary<TKey, TValue>.Node(node2.m_key, value, hashCode, node2.m_next);
                            if (node == null)
                            {
                                buckets[num] = node3;
                            }
                            else
                            {
                                node.m_next = node3;
                            }
                            resultingValue = value;
                        }
                        else
                        {
                            resultingValue = node2.m_value;
                        }
                        return false;
                    }
                    node = node2;
                }
                buckets[num] = new ConcurrentDictionary<TKey, TValue>.Node(key, value, hashCode, buckets[num]);
                this.m_countPerLock[num2]++;
                if (this.m_countPerLock[num2] > buckets.Length / this.m_locks.Length)//这个扩容标准比Dictionary要严一点哈~
                {
                    flag = true;
                }
            }
            finally
            {
                if (flag2)
                {
                    Monitor.Exit(this.m_locks[num2]);
                }
            }
            break;
        }
        if (flag)
        {
            this.GrowTable(buckets);
        }
        resultingValue = value;
        return true;
    }
}

 

比较有意思的是枚举器的实现，因为我们这个字段并没有维护version版本号哦~~~，看看他是怎么解决并发问题的：

public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
{
    ConcurrentDictionary<TKey, TValue>.Node[] buckets = this.m_buckets;
    for (int i = 0; i < buckets.Length; i++)
    {
        ConcurrentDictionary<TKey, TValue>.Node node = buckets[i];
        Thread.MemoryBarrier();
        while (node != null)
        {
            yield return new KeyValuePair<TKey, TValue>(node.m_key, node.m_value);
            node = node.m_next;
        }
    }
    yield break;
}

 

我们看着这个实现完全是无锁的，但也是不准确的，因为如果正好碰上扩展就不对了，不过对于并发字典这没什么问题。