Netty源码分析-DefaultAttributeMap

package io.netty.util;

import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.atomic.AtomicReferenceArray;
import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;

/**
 * Default {@link AttributeMap} implementation which use simple synchronization per bucket to keep the memory overhead
 * as low as possible.
 */
public class DefaultAttributeMap implements AttributeMap {

    //以原子方式更新attributes变量的引用
    @SuppressWarnings("rawtypes")
    private static final AtomicReferenceFieldUpdater<DefaultAttributeMap, AtomicReferenceArray> updater =
            AtomicReferenceFieldUpdater.newUpdater(DefaultAttributeMap.class, AtomicReferenceArray.class, "attributes");

    //默认桶的大小
    private static final int BUCKET_SIZE = 4;

    //掩码 桶大小-1
    private static final int MASK = BUCKET_SIZE  - 1;

    //延迟初始化，节约内存
    // Initialize lazily to reduce memory consumption; updated by AtomicReferenceFieldUpdater above.
    @SuppressWarnings("UnusedDeclaration")
    private volatile AtomicReferenceArray<DefaultAttribute<?>> attributes;

    @SuppressWarnings("unchecked")
    @Override
    public <T> Attribute<T> attr(AttributeKey<T> key) {
        if (key == null) {
            throw new NullPointerException("key");
        }
        AtomicReferenceArray<DefaultAttribute<?>> attributes = this.attributes;

        //当attributes为空时则创建它，默认数组长度4
        if (attributes == null) {
            //没有使用ConcurrentHashMap为了节约内存
            // Not using ConcurrentHashMap due to high memory consumption.
            attributes = new AtomicReferenceArray<DefaultAttribute<?>>(BUCKET_SIZE);

            //原子方式更新attributes，如果attributes为null则把新创建的对象赋值
            //原子方式更新解决了并发赋值问题
            if (!updater.compareAndSet(this, null, attributes)) {
                attributes = this.attributes;
            }
        }

        //根据key计算下标
        int i = index(key);

        //返回attributes数组中的第一个元素
        DefaultAttribute<?> head = attributes.get(i);

        //头部为空说明第一次添加，这个方法可能多个线程同时调用，因为判断head全部为null
        if (head == null) {
            // No head exists yet which means we may be able to add the attribute without synchronization and just
            // use compare and set. At worst we need to fallback to synchronization and waste two allocations.

            //创建一个空对象为链表结构的起点
            head = new DefaultAttribute();

            //创建一个attr对象，把head传进去
            DefaultAttribute<T> attr = new DefaultAttribute<T>(head, key);

            //链表头head的next = attr
            head.next = attr;
            //attr的prev = head
            attr.prev = head;

            //给数组i位置赋值，这里用compareAndSet原子更新方法解决并发问题
            //只有i位置为null能够设置成功，且只有一个线程能设置成功
            if (attributes.compareAndSet(i, null, head)) {
                //设置成功后返回attr
                // we were able to add it so return the attr right away
                return attr;
            } else {
                //设置失败的，说明数组i位置已经被其它线程赋值
                //所以要把head重新赋值，不能用上面new出来的head，需要拿到之前线程设置进去的head
                head = attributes.get(i);
            }
        }

        //对head同步加锁
        synchronized (head) {
            //curr 赋值为head    head为链表结构的第一个变量
            DefaultAttribute<?> curr = head;
            for (;;) {
                //依次获取next
                DefaultAttribute<?> next = curr.next;
                //next==null，说明curr为最后一个元素
                if (next == null) {
                    //创建一个新对象传入head和key
                    DefaultAttribute<T> attr = new DefaultAttribute<T>(head, key);
                    //curr后面指向attr
                    curr.next = attr;
                    //attr的前面指向curr
                    attr.prev = curr;
                    //返回新对象
                    return attr;
                }

                //如果next的key等于传入的key，并且没有被移除
                if (next.key == key && !next.removed) {
                    //这直接返回next
                    return (Attribute<T>) next;
                }
                //否则把curr变量指向下一个元素
                curr = next;
            }
        }
    }

    @Override
    public <T> boolean hasAttr(AttributeKey<T> key) {
        if (key == null) {
            throw new NullPointerException("key");
        }

        //attributes为null直接返回false
        AtomicReferenceArray<DefaultAttribute<?>> attributes = this.attributes;
        if (attributes == null) {
            // no attribute exists
            return false;
        }

        //计算数组下标
        int i = index(key);

        //获取头 为空直接返回false
        DefaultAttribute<?> head = attributes.get(i);
        if (head == null) {
            // No attribute exists which point to the bucket in which the head should be located
            return false;
        }

        //对head同步加锁
        // We need to synchronize on the head.
        synchronized (head) {
            // Start with head.next as the head itself does not store an attribute.
            //从head的下一个开始，因为head不存储元素
            DefaultAttribute<?> curr = head.next;

            //为null说明没有节点了
            while (curr != null) {
                //key一致并且没有被移除则返回true
                if (curr.key == key && !curr.removed) {
                    return true;
                }
                //curr指向下一个
                curr = curr.next;
            }
            return false;
        }
    }

    private static int index(AttributeKey<?> key) {
        //与掩码&运算，数值肯定<=mask 正好是数组下标
        return key.id() & MASK;
    }
}