编程语言
首页 > 编程语言> > C#基础教程(十二) 深扒ConcurrentDictionary

C#基础教程(十二) 深扒ConcurrentDictionary

作者:互联网

一 问题

最近用CocurrentDictionary遇到一个问题,暂时无法理解,多线程操作,foreach循环报错:关键字不在字典中。所有线程都没有删除元素,只做没key增加和有key修改的操作,更奇怪的是在中断时看了keys数组集合,明明有,闹心又无语。逻辑大致如下,有会的大佬帮我解释下:

//报错:关键字不在字典中,keys里明明有当前出错key
oreach(var key in conDic.keys){
    byte[] byts=conDic[key]
}

二 理解ConcurrentDictionary

出于上述问题,准备扒下源码,结合前辈知识,做下归纳。 

如图 ConcurrentDictionary的数据结构,其中有个tables 对象主要存储,而这个 tables 是一个 很多区块的数组 ,每个区块 又是一个node的链表 (一个node 就是一个key value 对)。

private volatile ConcurrentDictionary<TKey, TValue>.Tables m_tables;
private class Tables
{
    internal readonly ConcurrentDictionary<TKey, TValue>.Node[] m_buckets;
    internal readonly object[] m_locks;
    internal volatile int[] m_countPerLock;
    internal readonly IEqualityComparer<TKey> m_comparer;

    internal Tables(ConcurrentDictionary<TKey, TValue>.Node[] buckets, object[] locks, int[] countPerLock, IEqualityComparer<TKey> comparer)
    {
        this.m_buckets = buckets;
        this.m_locks = locks;
        this.m_countPerLock = countPerLock;
        this.m_comparer = comparer;
    }
}

private class Node
{
    internal TKey m_key;
    internal TValue m_value;
    internal volatile ConcurrentDictionary<TKey, TValue>.Node m_next;
    internal int m_hashcode;

    internal Node(TKey key, TValue value, int hashcode, ConcurrentDictionary<TKey, TValue>.Node next)
    {
        this.m_key = key;
        this.m_value = value;
        this.m_next = next;
        this.m_hashcode = hashcode;
    }
}

看这个Node类是一个带next 指针的结构 ,一个node就是链表  ,而Tables类中 m_buckets 变量便是一个存储了n个链表的列表结构。

其中Tables类中有个变量名为 countPerLock 类型为 int[] 便是图中最下面那个框这个,可以理解为每个锁对应的node数量,这个变量主要是用来统计字典中数据的个数 ,这个 countPerLock 数组值总和与m_buckets 真实数量一致,何为真实数量,就是非null。这个数组长度是与m_locks长度一致的。

Count()这个方法便是主要使用这个元素经行统计。这样的好处是不用遍历node链表。

最重要的是Tables 中m_locks的实现。这是一个锁的列表其中用来控制多线程读取修改时控制的区块 。

当字典初始化的时候 m_locks 的数量为 cpu内核数*4(ps:例如i7 就是8*4=32) 而 m_buckets 数量初始化是31(有个小条件是m_locks>=m_buckets 时 m_locks=m_buckets) 所以i7 下 m_buckets 和 m_locks 都是32个 ,理论上再,不添加新节点的时候 一个区块对应 一个锁。

m_locks:锁对象,object类型,初始化时是默认值是 cpu内核数*4 ,最大值是 1024个

m_buckets:初始化默认值 31,最大值是2146435071

也就是说,如果字典中数据量大的时候是一个锁对象对应n个Node链表。

关于ConcurrentDictionary中所有读取操作

例如Keys Values Count 这类的属性 会对锁定 m_locks 中所有的锁对象 所以需要谨慎使用。

而常用的索引器[]和 TryGetValue 等方法 未锁定任何锁对象,并通过 Volatile.Read 原子性读取 对应的Node链表 遍历中所有元素 直到找到 对应的key 为止。

关于ConcurrentDictionary中所有写操作

当添加一个新数据时 方法会计算key的hashcode  是放到哪个node里表中 然后锁定对应的锁对象,自后 通过 Volatile.Write 方法 替换新的Node的指向 , 这时node为新的值 它的next 指向原先的Node值。

private void GetBucketAndLockNo(int hashcode, out int bucketNo, out int lockNo, int bucketCount, int lockCount)
{
    bucketNo = (hashcode & int.MaxValue) % bucketCount; //Node的位置
    lockNo = bucketNo % lockCount; // 锁位置
}  
Volatile.Write<ConcurrentDictionary<TKey, TValue>.Node>(ref tables.m_buckets[bucketNo], new ConcurrentDictionary<TKey, TValue>.Node(key, value, hashCode, tables.m_buckets[bucketNo]));

为什么这么设计?

对于多线程 这种多个链表 多个锁对象 可以提升多个线程同时操作的可能性 ,因为很大的程度上写操作的数据  并不是一个锁对象负责的。

同时链式的存储对于添加对象而言内存的操作更方便。再看看几个函数:

public TValue this[TKey key]
{
	[__DynamicallyInvokable]
	get
	{
		TValue result;
		if (!this.TryGetValue(key, out result))
		{
			throw new KeyNotFoundException();
		}
		return result;
		}
		[__DynamicallyInvokable]
	set
	{
		if (key == null)
		{
			throw new ArgumentNullException("key");
		}
		TValue tvalue;
		this.TryAddInternal(key, value, true, true, out tvalue);
	}
}
[__DynamicallyInvokable]
public bool TryGetValue(TKey key, out TValue value)
{
	if (key == null)
	{
		throw new ArgumentNullException("key");
	}
	ConcurrentDictionary<TKey, TValue>.Tables tables = this.m_tables;
	IEqualityComparer<TKey> comparer = tables.m_comparer;
	int num;
	int num2;
	this.GetBucketAndLockNo(comparer.GetHashCode(key), out num, out num2, tables.m_buckets.Length, tables.m_locks.Length);
	for (ConcurrentDictionary<TKey, TValue>.Node node = Volatile.Read<ConcurrentDictionary<TKey, TValue>.Node>(ref tables.m_buckets[num]); node != null; node = node.m_next)
	{
		if (comparer.Equals(node.m_key, key))
		{
			value = node.m_value;
			return true;
		}
	}
	value = default(TValue);
	return false;
}

上面代码是报关键字不在字典中错误,可能TryGetValue没锁住而造成的。如果一个线程TryRemove(),一个线程取值,那么很容易造成Volatile.Rea()读到null,这个报关键字不在字典中就解释的通!

标签:Node,基础教程,locks,C#,buckets,ConcurrentDictionary,int,key
来源: https://blog.csdn.net/yangwenxue1989/article/details/121393682