C#异步编程（五）异步的同步构造

public sealed class AsyncOneManyLock
{
    #region 锁的代码
    //自旋锁不要用readonly
    private SpinLock m_lock = new SpinLock(true);

    private void Lock()
    {
        bool taken = false;m_lock.Enter(ref taken);
    }
    private void Unlock()
    {
        m_lock.Exit();
    }

    #endregion

    #region 锁的状态和辅助方法

    private Int32 m_state = 0;
    private bool IsFree { get { return m_state == 0; } }
    private bool IsOwnedByWriter { get { return m_state == -1; } }
    private bool IsOwnedByReader { get { return m_state > 0; } }
    private Int32 AddReaders(Int32 count) { return m_state += count; }
    private Int32 SubtractReader() { return --m_state; }
    private void MakeWriter() { m_state = -1; }
    private void MakeFree() { m_state = 0; }

    #endregion

    //目的实在非竞态条件时增强性能和减少内存消耗
    private readonly Task m_noContentionAccessGranter;
    //每个等待的writer都通过他们在这里排队的TaskCompletionSource来唤醒
    private readonly Queue> m_qWaitingWriters = new Queueobject>>();
    //一个TaskCompletionSource收到信号，所有等待的reader都唤醒
    private TaskCompletionSource

private bool TryRemoveInternal(TKey key, out TValue value, bool matchValue, TValue oldValue)
{
    int hashcode = _comparer.GetHashCode(key);
    while (true)
    {
        Tables tables = _tables;
        int bucketNo, lockNo;
        //这里获取桶的索引和锁的索引，注意，锁的索引和桶未必是同一个值，具体算法看源码。
        GetBucketAndLockNo(hashcode, out bucketNo, out lockNo, tables._buckets.Length, tables._locks.Length);
        //这里锁住的只是对应这个index指向的锁，而不是所有锁。
        lock (tables._locks[lockNo])
        {
            //这里table可能被重新分配，所以这里再次获取，看得到的是不是同一个table
            // If the table just got resized, we may not be holding the right lock, and must retry.
            // This should be a rare occurrence.
            if (tables != _tables)
            {
                continue;
            }

            Node prev = null;
            //这里同一个桶，可能因为连地址，有很多值，所以要对比key
            for (Node curr = tables._buckets[bucketNo]; curr != null; curr = curr._next)
            {
                Debug.Assert((prev == null && curr == tables._buckets[bucketNo]) || prev._next == curr);
                //对比是不是要删除的的那个元素
                if (hashcode == curr._hashcode && _comparer.Equals(curr._key, key))
                {
                    if (matchValue)
                    {
                        bool valuesMatch = EqualityComparer.Default.Equals(oldValue, curr._value);
                        if (!valuesMatch)
                        {
                            value = default(TValue);
                            return false;
                        }
                    }
                    //执行删除，判断有没有上一个节点。然后修改节点指针或地址。
                    if (prev == null)
                    {
                        Volatile.Write(ref tables._buckets[bucketNo], curr._next);
                    }
                    else
                    {
                        prev._next = curr._next;
                    }

                    value = curr._value;
                    tables._countPerLock[lockNo]--;
                    return true;
                }
                prev = curr;
            }
        }
        value = default(TValue);
        return false;
    }
}

/// 

/// Shared internal implementation for inserts and updates.
/// If key exists, we always return false; and if updateIfExists == true we force update with value;
/// If key doesn‘t exist, we always add value and return true;
/// 
private bool TryAddInternal(TKey key, int hashcode, TValue value, bool updateIfExists, bool acquireLock, out TValue resultingValue)
{
    Debug.Assert(_comparer.GetHashCode(key) == hashcode);
    while (true)
    {
        int bucketNo, lockNo;
        Tables tables = _tables;
//老方法了，不多说，获取hash索引和锁索引
        GetBucketAndLockNo(hashcode, out bucketNo, out lockNo, tables._buckets.Length, tables._locks.Length);
        bool resizeDesired = false;
        bool lockTaken = false;
        try
        {
            //这里都是true的，所以会获取锁
            if (acquireLock)
                Monitor.Enter(tables._locks[lockNo], ref lockTaken);

            // If the table just got resized, we may not be holding the right lock, and must retry.
            // This should be a rare occurrence.
            if (tables != _tables)
            {
                continue;
            }

            // Try to find this key in the bucket
            Node prev = null;
            //查看对应的桶里，
            for (Node node = tables._buckets[bucketNo]; node != null; node = node._next)
            {
                Debug.Assert((prev == null && node == tables._buckets[bucketNo]) || prev._next == node);
                //查看有没有相同的key值，有就返回false
                if (hashcode == node._hashcode && _comparer.Equals(node._key, key))
                {
                    // The key was found in the dictionary. If updates are allowed, update the value for that key.
                    // We need to create a new node for the update, in order to support TValue types that cannot
                    // be written atomically, since lock-free reads may be happening concurrently.
                    //这个应该是addorupdate使用的，存在就更新。
                    if (updateIfExists)
                    {
                        if (s_isValueWriteAtomic)
                        {
                            node._value = value;
                        }
                        else
                        {
                            Node newNode = new Node(node._key, value, hashcode, node._next);
                            if (prev == null)
                            {
                                Volatile.Write(ref tables._buckets[bucketNo], newNode);
                            }
                            else
                            {
                                prev._next = newNode;
                            }
                        }
                        resultingValue = value;
                    }
                    else
                    {
                        resultingValue = node._value;
                    }
                    return false;
                }
                prev = node;
            }
            
            // The key was not found in the bucket. Insert the key-value pair.
            Volatile.Write(ref tables._buckets[bucketNo], new Node(key, value, hashcode, tables._buckets[bucketNo]));
            //这里checked检查是否存在溢出。
            checked
            {
                tables._countPerLock[lockNo]++;
            }
            // If the number of elements guarded by this lock has exceeded the budget, resize the bucket table.
            // It is also possible that GrowTable will increase the budget but won‘t resize the bucket table.
            // That happens if the bucket table is found to be poorly utilized due to a bad hash function.
            // _budget是 The maximum number of elements per lock before a resize operation is triggered
            if (tables._countPerLock[lockNo] > _budget)
            {
                resizeDesired = true;
            }
        }
        finally
        {
            if (lockTaken)
                Monitor.Exit(tables._locks[lockNo]);
        }
        // The fact that we got here means that we just performed an insertion. If necessary, we will grow the table.
        //
        // Concurrency notes:
        // - Notice that we are not holding any locks at when calling GrowTable. This is necessary to prevent deadlocks.
        //As a result, it is possible that GrowTable will be called unnecessarily. But, GrowTable will obtain lock 0

        //   and then verify that the table we passed to it as the argument is still the current table.
        if (resizeDesired)
        {
            GrowTable(tables);
        }
//赋值
        resultingValue = value;
        return true;
    }
}