9-HashMap及ConcurrentHashMap底层原理剖析

于 2025-03-11 09:24:50 发布
阅读量353 收藏 3
点赞数 4
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kongxubihai/article/details/146170122
版权

HashMap

基本原理

HashMap底层采用数组+链表+红黑树的形式来存储数据。

  1. 首先插入数据之前，会对使用一个hash算法计算key的hash值，然后根据此hash值对数组长度进行取模，得出该key存储在数组的第几个元素上
  2. 如上图黄色部分k = 1，v = 2，刚开始数组的此位置未存储元素，则此时不存在hash冲突，直接存储在此数组的位置即可
  3. 加入存在hash冲突，如上红色部分所示，则首先使用链表来解决hash冲突，新存入的元素放在链表末尾
  4. 如果hash冲突变多，此时使用链表查询数据时间复杂度是O(n)，为了提高查询性能，而将链表进行树化，将转化成一颗红黑树，此时查询性能为O(logN)，另外链表转成红黑树的条件是，当链表上的节点数量不少于8个的时候

源码分析

内部属性
// 默认的初始化容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
// 最大容量2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
// 负载因子0.75，比如数组的长度是16，当数组里元素的个数打到了数组大小的这个0.75比率，
// 也就是12个的时候，就会进行数组的扩容
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表红黑树化的条件，长度是8
static final int TREEIFY_THRESHOLD = 8;
// 非树化的添加，长度小于等于6
static final int UNTREEIFY_THRESHOLD = 6;
// 树化之前的最小容量必须打到64，否则优先进行扩容而不是进行树化
static final int MIN_TREEIFY_CAPACITY = 64;
// HashMap内部的基础数组，HashMap是使用数组+链表+红黑树的方式来存储数据
transient Node<K,V>[] table;
构造方法
public HashMap() {
    // 默认构造函数，只是初始化了一个负载因子，其它啥都没干
    this.loadFactor = DEFAULT_LOAD_FACTOR;
}
// 设置容量的构造方法
public HashMap(int initialCapacity) {
    this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
// 设置容量和负载因子的构造方法
public HashMap(int initialCapacity, float loadFactor) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal initial capacity: " +
                                           initialCapacity);
    // 容量不可超过最大允许值 MAXIMUM_CAPACITY
    if (initialCapacity > MAXIMUM_CAPACITY)
        initialCapacity = MAXIMUM_CAPACITY;
    if (loadFactor <= 0 || Float.isNaN(loadFactor))
        throw new IllegalArgumentException("Illegal load factor: " +
                                           loadFactor);
    this.loadFactor = loadFactor;
    // 调用tableSizeFor方法，// 计算下次扩容的阈值：保证返回的值一定是2的多少次方，如15则返回16
    this.threshold = tableSizeFor(initialCapacity);
}
put方法
    public V put(K key, V value) {
        // 先hash
        // 然后调用 putVal
        return putVal(hash(key), key, value, false, true);
    }
hash方法
// 将1个32位的高16位和低16位做异或运算,减少hash碰撞
static final int hash(Object key) {
    int h;
    // 1. 如果key == null直接返回0，这也就是为啥HashMap能使用null作为key的原因
    // 2. (h = key.hashCode()) 获取key的hashCode保存在h变量中
    // 3. h ^ (h >>> 16) 这个代码的意思是将一个32位的高16位和低16位进行异或运算
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
putVal()方法
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        // 数组
        Node<K,V>[] tab;
        // 节点值
        Node<K,V> p;
        // n数组长度，n是分配到的数组位置
        int n, i;
        // 1、数组空或是长度0，先进行数组初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            // 数组初始化
            n = (tab = resize()).length;
        // 2、数组对应位置没有元素，直接存储。此处 位运算 （n-1）& h = n%h 相等，效率高，前提是前面要去的n是2的N次方
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 3.2 冲突的节点是一个红黑树，按照红黑树的方式插入
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                // 3.3 到此处说明是链表节点，按照链表方式插入
                // 从链表头遍历到尾
                for (int binCount = 0; ; ++binCount) {
                    // 插入一个新节点 然后跳出循环
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 插入一个节点后，列表长度达到8，触发链表转成红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 遍历中同样节点已经存在，替换值
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key
                // 获取修改前旧节点的值，返回旧的值
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                // 钩子
                afterNodeAccess(e);
                return oldValue;
            }
        }
        // 记录修改的次数
        ++modCount;
        // 4、数组元素个数大于扩容阈值，触发扩容操作
        if (++size > threshold)
            resize();
        // 钩子
        afterNodeInsertion(evict);
        return null;
    }

流程图

resize()扩容方法
final Node<K,V>[] resize() {
    // 旧数组
    Node<K,V>[] oldTab = table;
    // 旧的容量
    int oldCap = (oldTab == null) ? 0 : oldTab.length;
    // 旧的扩容容量
    int oldThr = threshold;
    // 新的容量和新的扩容容量
    int newCap, newThr = 0;
    if (oldCap > 0) {
        // 1、旧数组非空且达到了最大容量，直接返回无法扩容
        if (oldCap >= MAXIMUM_CAPACITY) {
            threshold = Integer.MAX_VALUE;
            return oldTab;
        }
            // 扩容1倍，小于最大容量，大于最小容量
        else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                 oldCap >= DEFAULT_INITIAL_CAPACITY)
            newThr = oldThr << 1; // double threshold
    }
    else if (oldThr > 0) // initial capacity was placed in threshold
        // 此处说明 oldCap =0, oldThr >0
        newCap = oldThr;
    else {               // zero initial threshold signifies using defaults
        // 走到这里说明 oldCap = 0 &&  oldThr = 0 ，赋予默认初始值
        newCap = DEFAULT_INITIAL_CAPACITY;
        newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
    }
    // 如果扩容容量=0 重新计算
    if (newThr == 0) {
        float ft = (float)newCap * loadFactor;
        newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                  (int)ft : Integer.MAX_VALUE);
    }

    // 赋值扩容阈值 以下是扩容或是初始化
    threshold = newThr;
    // 新数组，长度上新的容量
    @SuppressWarnings({"rawtypes","unchecked"})
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
    table = newTab;
    if (oldTab != null) {
        // 2、数据的移动，将旧的数组移动新扩容的数组上去
        for (int j = 0; j < oldCap; ++j) {
            Node<K,V> e;
            // 获取 oldTab[i] 赋值给 e , 代表旧数组中数据的位置，
            if ((e = oldTab[j]) != null) {
                // 赋值null ，垃圾回收
                oldTab[j] = null;
                // 3.1 单单的数组节点，直接寻址法定位并赋值到新数组
                if (e.next == null)
                    newTab[e.hash & (newCap - 1)] = e;
                    // 3.2 红黑树节点，调用split()拆成链表移动到新数组
                else if (e instanceof TreeNode)
                    ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    // 3.3 链表节点，拆成2个链表，因为是2倍的扩容，hash & oldCap =0 一个链表，hash & oldCap =1 另外一个链表
                else { // preserve order
                    Node<K,V> loHead = null, loTail = null;
                    Node<K,V> hiHead = null, hiTail = null;
                    Node<K,V> next;
                    do {
                        next = e.next;
                        if ((e.hash & oldCap) == 0) {
                            if (loTail == null)
                                loHead = e;
                            else
                                loTail.next = e;
                            loTail = e;
                        }
                        else {
                            if (hiTail == null)
                                hiHead = e;
                            else
                                hiTail.next = e;
                            hiTail = e;
                        }
                    } while ((e = next) != null);
                    if (loTail != null) {
                        loTail.next = null;
                        // 位置不用变 hash & oldCap =0
                        newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                        hiTail.next = null;
                        //  hash & oldCap =1 直接加上原谅的容量即可，避免了重新hash
                        newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
    return newTab;
}

流程图

remove方法
final Node<K,V> removeNode(int hash, Object key, Object value,
                           boolean matchValue, boolean movable) {
    Node<K,V>[] tab; Node<K,V> p; int n, index;
    // 数组非空 对应位置非空
    if ((tab = table) != null && (n = tab.length) > 0 &&
        (p = tab[index = (n - 1) & hash]) != null) {
        Node<K,V> node = null, e; K k; V v;
        // 1、普通节点
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            node = p;
        else if ((e = p.next) != null) {
            // 2、树节点获取
            if (p instanceof TreeNode)
                node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
            else {
                // 3、链表节点获取
                do {
                    if (e.hash == hash &&
                        ((k = e.key) == key ||
                         (key != null && key.equals(k)))) {
                        node = e;
                        break;
                    }
                    p = e;
                } while ((e = e.next) != null);
            }
        }
        if (node != null && (!matchValue || (v = node.value) == value ||
                             (value != null && value.equals(v)))) {
            // 树节点移除
            if (node instanceof TreeNode)
                ((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
                // 普通节点
            else if (node == p)
                tab[index] = node.next;
            else
                // 链表节点
                p.next = node.next;
            ++modCount;
            --size;
            afterNodeRemoval(node);
            return node;
        }
    }
    return null;
}

原理和putVal()类似：

  1. 先判断是普通节点、树节点、链表节点类型
  2. 按照对应的类型处理

ConcurrentHashMap原理和源码分析

JDK7 实现

在JDK1.7中ConcurrentHashMap采用了HashMap + ReentrantLock + Segment的方式实现。

  1. ConcurrentHashMap中的分段锁称为Segment，它类似于HashMap的结构，即：内部拥有一个Entry数组，数组中的每个元素又是一个链表，同时又是一个ReentrantLock（Segment继承了ReentrantLock）。
  2. ConcurrentHashMap使用分段锁技术，将数据分成一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据的时候，其他段的数据也能被其他线程访问，能够实现真正的并发访问。
  3. 优点：写操作的时候可以只对元素所在的Segment进行加锁即可，不会影响到其他的Segment
  4. 缺点：Hash的过程要比普通的HashMap要长

JDK8 实现

ConcurrentHashMap结构基本上和HashMap一样 ，采用了HashMap（数组 + 链表 + 红黑树） + synchronized + CAS 的实现方式来设计。读操作使用volatile，写操作使用synchronized 和CAS。

  1. CAS ：在判断数组中当前位置为null的时候，使用CAS把这个新的Node写入数组中对应的位置。
  2. synchronized ：当数组中的指定位置不为空时，通过加锁来添加这个节点进入数组(链表<8)或者是红黑树（链表>=8）
  3. JDK8中采用的是Node（放弃了Segment）。Node：保存key，value及key的hash值的数据结构。其中value和next都用volatile修饰，保证并发的可见性。

JDK8的源码实现分析

类属性
// 最大容量上限，2的30次方
private static final int MAXIMUM_CAPACITY = 1 << 30;

// 默认的初始化容量16
private static final int DEFAULT_CAPACITY = 16;

// 最大的数组长度上限
static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

// 默认并发能力层级，16
// （默认数组长度是16，每个数组元素都可作为一把锁，所以数组长度是多少默认就有多少把锁）
private static final int DEFAULT_CONCURRENCY_LEVEL = 16;
// 负载因子
private static final float LOAD_FACTOR = 0.75f;
// 红黑树转化条件（链表长度达到8需要转成红黑树，提高查询效率）
static final int TREEIFY_THRESHOLD = 8;
// 非树化条件（红黑树大小小于等于6时候，需要将红黑树转成链表）
static final int UNTREEIFY_THRESHOLD = 6;
// 红黑树化前最小容量（如果当前容量小于64，首先考虑扩容减少hash冲突，而不是进行树化）
static final int MIN_TREEIFY_CAPACITY = 64;

private static final int MIN_TRANSFER_STRIDE = 16;

private static int RESIZE_STAMP_BITS = 16;

private static final int MAX_RESIZERS = (1 << (32 - RESIZE_STAMP_BITS)) - 1;

private static final int RESIZE_STAMP_SHIFT = 32 - RESIZE_STAMP_BITS;
// 标志位，说明当前正在扩容操作，该位置数据正在移动，也就是move（移动）的意思
static final int MOVED = -1;
// 标志位，说明改位置的数据正在进行树化
static final int TREEBIN = -2;
// 保留位置
static final int RESERVED = -3;
// 进行hash算法的时候，保留多少位hash结果，这里是保留int类型中的后31位
static final int HASH_BITS = 0x7fffffff; // usable bits of normal node hash
// 当前机器的cpu核数
static final int NCPU = Runtime.getRuntime().availableProcessors();
// 保存数据的基础数组，使用volatile修饰，保证多线程之间的可见性
transient volatile Node<K,V>[] table;
// 扩容期间的另外一个数组，ConcurrentHashMap扩容期间两个数组都在使用
private transient volatile Node<K,V>[] nextTable;
// 用作大小统计的基础窗口
// ConcurrentHashMap使用多窗口分段锁机制来进行数量统计，提高并发性能
private transient volatile long baseCount;
// 一个标志位，用作数组初始化或者扩容期间的标识
private transient volatile int sizeCtl;
// 扩容期间，下一个需要进行数组迁移的数组下标
private transient volatile int transferIndex;
//
private transient volatile int cellsBusy;
// 窗口列表，用多窗口机制来减少锁冲突，提高高并发的计数统计性能
private transient volatile CounterCell[] counterCells;

putVal方法源码分析

亮点或是教科书实现：

  1. 调用initTable方法初始化数组的时候，这个是能保证线程安全的，同一个时间只能有一个线程进行初始化
  2. helpTransfer方法是能进行多线程扩容的，这里保证并发安全的同时还能多线程协作扩容，提升效率
  3. synchronized(f)，只是路由到的哪个数组元素，就对那个元素进行加锁，加锁的粒度很小
  4. 新增元素，调用addCount方法使用多窗口分段锁思想，进行数量统计，这里也能减少所冲突，提升性能

final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    // 使用spread函数，得出一个新的hash值
    // 跟上一章节讲的HashMap的hash函数核心思想一样
    // 低16位结果变为高低16位的异或值
    int hash = spread(key.hashCode());
    int binCount = 0;
    // 使用一个无限循环，知道putVal操作成功才退出
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 如果基础数组为空或者长度为零，说明还未初始化
        if (tab == null || (n = tab.length) == 0)
            // 首先进行数组的初始化
            tab = initTable();
        // 走到这里说明table数组已经初始化了，肯定不为空
        // 根据寻址算法 (n-1)&hash 找到数组的table[i]位置
        // 如果table[i] == null说明该位置之前没存储元素
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
            // 创建一个新的Node节点，使用cas操作将node设置到table[i]位置
            // cas保证原子性，由于table使用volatile关键字修饰，保证可见性、有序性；所以是并发安全的
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                // cas成功则退出循环，否则继续
                break;
        }
        // 如果f=table[i]的hash值被标记为MOVED，说明当前正在进行扩容
        else if ((fh = f.hash) == MOVED)
            // 则当前线程帮助进行扩容（多线程扩容，缩短扩容时间）
            // 扩容完成之后再进行重试
            tab = helpTransfer(tab, f);
        else {
            V oldVal = null;
            // 注意这里使用的synchronized进行加锁，加锁的元素是f=table[i]
            // 加锁的是数组的一个元素，通过寻址算法落到哪个位置，就对哪个位置进行加锁
            // 保证并发安全的同时，加锁粒度很小，只要并发操作hash冲突不大，锁冲突就不大
            // 这里就是分段锁的思想了，table数组的每个元素都可以作为一把锁
            // 并发操作时，hash冲突时候才会存在锁竞争
            synchronized (f) {
                // tabAt获取table[i]位置元素，二次确认此Node对象是否还是原来哪个，没被修改过
                if (tabAt(tab, i) == f) {
                    // fh=f.hash >= 0 说明未扩容或者红黑树化
                    // 在扩容或者初始化的时候会把table[i]所在元素的hash改为小于0
                    // 表示正在进行扩容、移动数据、进行树化等操作
                    if (fh >= 0) {
                        binCount = 1;
                        // 这里就跟之前HashMap一样，就是从头遍历链表
                        // 一个个查找节点是否Key与传入一样，如果一样则替换value值即可
                        // 如果不一样，则在链表尾部插入一个新的节点
                        // 由于使用了synchronized，是并发安全的
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {
                                oldVal = e.val;
                                if (!onlyIfAbsent)
                                    e.val = value;
                                break;
                            }
                            Node<K,V> pred = e;
                            if ((e = e.next) == null) {
                                pred.next = new Node<K,V>(hash, key,
                                                          value, null);
                                break;
                            }
                        }
                    }
                    // 如果f节点是红黑树
                    else if (f instanceof TreeBin) {
                        Node<K,V> p;
                        binCount = 2;
                        // 对红黑树进行遍历，如果有节点Key与传入key一直，则替换value值即可
                        // 否则需要插入一个新的节点
                        if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                       value)) != null) {
                            oldVal = p.val;
                            if (!onlyIfAbsent)
                                p.val = value;
                        }
                    }
                }
            }
            if (binCount != 0) {
               // 达到了树化条件，table[i]位置的链表转成红黑树
                if (binCount >= TREEIFY_THRESHOLD)
                    treeifyBin(tab, i);
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 这里使用并发多窗口分段统计的思想，进行计数统计
    addCount(1L, binCount);
    return null;
}

initTable源码分析
  1. 第一个进行扩容的线程会将sizeCtl设置为-1，由于使用了volatile修饰，保证可见性
  2. 后面进来的线程读取sizeCtl立即可见，发现为-1，说明有人正在初始化了，自己等待初始化完成即可
private final Node<K,V>[] initTable() {
    Node<K,V>[] tab; int sc;
    // 无限循环，直到成功才退出
    while ((tab = table) == null || tab.length == 0) {
        // sizeCtl初始值是0，使用volatile修饰保证可见性、有序性
        // 第一个进行初始化的线程会将sizeCtl使用cas操作设置为-1
        // 后面第二、第三个线程发现sizeCtl < 0 发现已经有线程在进行初始化操作了
        // 自己就不需要操作了，直接等待初始化完成即可
        if ((sc = sizeCtl) < 0)
            Thread.yield(); // lost initialization race; just spin
        // 走到这里，发现自己是第一个初始化的人，设置sizeCtl初始化标志位-1
        else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
            try {
                if ((tab = table) == null || tab.length == 0) {
                    int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                    @SuppressWarnings("unchecked")
                    // 这里就没啥好说的了，就是初始化一个数组出来
                    Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];
                    table = tab = nt;
                    // 初始化好数组之后，sc代表下一次扩容的阈值，默认是12
                    sc = n - (n >>> 2);
                }
            } finally {
                // 由于此时只有一个线程有操作权限，是线程安全的，直接修改即可
                // 设置下次扩容的阈值为sc，也就是12
                sizeCtl = sc;
            }
            break;
        }
    }
    return tab;
}
分段统计addCount方法源码
  1. 原理类比银行大厅的办事窗口，可参考《Atomic原子类专题》中 LongAddr
  2. 新增操作，需要将容量+1，容量增加为了提升并发的性能，使用多窗口统计的机制，将竞争压力分散到多个窗口中
  3. 具体增加的操作是，首先竞争常规窗口，进行cas的自增1操作，如果失败则选择从备用窗口列表选择一个窗口，进行cas自增1操作
private final void addCount(long x, int check) {
    // as就是备用窗口列表
    CounterCell[] as; long b, s;
    // 如果备用窗口列表不为空，或者在基础窗口竞争失败，则取备用窗口列表操作
    if ((as = counterCells) != null ||
        // 这里的意思是基础窗口竞争失败
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
        CounterCell a; long v; int m;
        boolean uncontended = true;
        // 这里就是从备用窗口列表选一个备用窗口，进行操作了
        // 原理跟LongAdder基本一致的，这里就不详细分析了
        if (as == null || (m = as.length - 1) < 0 ||
            (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
            !(uncontended =
              U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
            fullAddCount(x, uncontended);
            return;
        }
        if (check <= 1)
            return;
        // 这里就是将基础窗口的数量+所有备用窗口的数量，得到容量总和
        s = sumCount();
    }
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        // 这里判断容量 s > sizeCtl，也就是达到了扩容阈值，需要进行扩容操作
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            int rs = resizeStamp(n);
            // 发现sizeCtl说明有线程正在进行扩容
            if (sc < 0) {
                if ((sc >>> RESIZE_STAMP_SHIFT) != rs || sc == rs + 1 ||
                    sc == rs + MAX_RESIZERS || (nt = nextTable) == null ||
                    transferIndex <= 0)
                    break;
                if (U.compareAndSwapInt(this, SIZECTL, sc, sc + 1))
                    // 进行扩容的方法
                    // 其它线程走到这里，也会取帮助进行扩容，多线程一起扩容
                    transfer(tab, nt);
            }
            // 走到这里说明sizeCtl >= 0，说明自己是第一个执行扩容的线程
            else if (U.compareAndSwapInt(this, SIZECTL, sc,
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                // 真正进行扩容的方法
                transfer(tab, null);
            s = sumCount();
        }
    }
}
汇总统计sumCount方法源码
final long sumCount() {
    // counterCells是备用窗口列表
    CounterCell[] as = counterCells; CounterCell a;
    // baseCount就是基础窗口的数量
    long sum = baseCount;
    // 这里就是将基础窗口数量 + 所有备用窗口的数量，就得到总数量了
    if (as != null) {
        for (int i = 0; i < as.length; ++i) {
            if ((a = as[i]) != null)
                sum += a.value;
        }
    }
    return sum;
}

kongxubihai
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值