java集合-ConcurrentHashMap源码概述（基于JDK1.8）

最新推荐文章于 2022-09-05 10:51:21 发布
最新推荐文章于 2022-09-05 10:51:21 发布
阅读量317 收藏
点赞数
分类专栏： Java集合 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/baidu_32689899/article/details/107085175
版权

目录

一、概述

二、源码说明

1，构造函数

1.1 无参的构造函数

1.2 指定容量、加载因子、并发级别的构造函数

2,put方法

2.1 initTable() 初始化Node数组的方法

2.2 addCount(long x, int check) 对node的数据进行统计，如果需要扩容则扩容

3，get方法

4，size方法

5，remove方法

三、对比

1，并发级别

2，数据结构

3，链表的插入

4，扩容

一、概述

jdk1.8的ConcurrentHashMap，取消了分段锁的概念，虽然在构造函数中可以指定并发级别这个参数，但是实际只是判断了如果初始容量小于并发级别，则把初识容量的值设置为并发级别的值，然后就没有用到并发级别这个参数了。因为在1.8中，锁更加的细化了，使用对Node数组的每个下标下的头节点元素进行加锁。就相当于容量有多少就有多少锁，锁住的是每一个桶。同时在进行扩容的时候还支持部分数据的访问不阻塞。

二、源码说明

1，构造函数

1.1 无参的构造函数

public ConcurrentHashMap() {
    }

如果是使用默认构造函数的话，初始容量默认为16.

1.2 指定容量、加载因子、并发级别的构造函数

出了这个三个参数的构造函数之外，还有另外两个构造函数，分别是：

ConcurrentHashMap(int initialCapacity)：指定初始容量；

ConcurrentHashMap(int initialCapacity, float loadFactor)：指定初始容量和加载因子；

这里就只对有三个参数的构造函数进行说明：

注意一个地方：初始容量会与加载因子有关。

public ConcurrentHashMap(int initialCapacity, float loadFactor, int concurrencyLevel) {
        // 对传入的参数进行校验
        if (!(loadFactor > 0.0f) || initialCapacity < 0 || concurrencyLevel <= 0)
            throw new IllegalArgumentException();
        // 如果容量小于并发级别，则把容量设置为与并发级别一样大小
        if (initialCapacity < concurrencyLevel)   // Use at least as many bins
            initialCapacity = concurrencyLevel;   // as estimated threads
        // 这里会根据传入的指定容量和加载因子来计算出了size
        long size = (long)(1.0 + (long)initialCapacity / loadFactor);
        // 然后会找到一个大于等于size的2的幂次方数
        int cap = (size >= (long)MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : tableSizeFor((int)size);
        // 对容量进行赋值
        this.sizeCtl = cap;
    }

2,put方法

put方法中调用putVal方法

key和value都不可以为null，否则会抛出异常

put流程：

  1. 根据key计算出hash值
  2. 如果Node数组为空则初始化该数组（初始化方法中使用cas操作保险并发安全）
  3. 根据hash值计算出数组下标
  4. 如果该下标下的Node为null则创建一个新的插入（使用CAS操作保证并发安全）
  5. 如果该下标下已经存在了Node元素则判断是链表还是红黑树，分别调用不同的方法来插入或者替换元素（使用synchronized同步代码块来保证并发安全）
  6. 插入元素完成后如果是链表则需要判断是否需要把链表转为红黑树（链表长度大于等于8则转换为红黑树）
  7. 最后对Node数组中的Node元素进行统计
public V put(K key, V value) {
        return putVal(key, value, false);
    }

    /** Implementation for put and putIfAbsent */
    final V putVal(K key, V value, boolean onlyIfAbsent) {
        // 判断key和value是否为null，如果是则抛出异常，说明该Map是不支持null值的
        if (key == null || value == null) throw new NullPointerException();
        // 根据key计算出hash值
        int hash = spread(key.hashCode());
        int binCount = 0;
        // 把Node数组赋值给局部变量tab之后，进入一个死循环
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            // 如果tab为null则需要初始化该数组
            if (tab == null || (n = tab.length) == 0)
                // 这里对Node数组进行初始化，该方法里会保证线程安全
                // 只有一个线程会成功执行数组的初始化，其他线程会直接返回初始化好的数组
                // 然后结束本次循环，进入下一次循环，下一次循环判断tab不为null之后就不会再执行到这里了
                tab = initTable();
            // (n - 1) & hash 计算出数组下标
            // tabAt方法为根据下标从内存取出Node数组中的元素
            // 如果该下标下的元素为null，则创建一个新的Node元素，使用cas操作设置到数组中
            // 当产生并发时，只会与一个线程设置成功，然后跳出循环
            else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                if (casTabAt(tab, i, null, new Node<K,V>(hash, key, value, null)))
                    break;                   // no lock when adding to empty bin
            }
            // 如果取出的f不为空，并且被标记为正在调整大小则进入此分支
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);// 帮助数据转移。
            // 如果node数组已经初始化了，并且要插入的下标位置已经有了数据，
            // 那么就需要对链表或者红黑树进行插入节点或者替换节点的操作
            else {
                V oldVal = null;
                // 使用synchronized锁，锁对象为该下标下的元素
                synchronized (f) {
                    // 拿到锁之后再判断一下这个f对象有没有被其他线程修改
                    // 如果被修改了的话，就先不做修改，等下次循环到这里的时候再判断能不能改
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            for (Node<K,V> e = f;; ++binCount) {
                                K ek;
                                // 如果是key相同是覆盖操作的话，这里if就成立
                                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;
                                }
                            }
                        }
                        // 如果是树结构则调用树结构的插入方法
                        else if (f instanceof TreeBin) {
                            Node<K,V> p;
                            binCount = 2;
                            if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key, value)) != null) {
                                oldVal = p.val;
                                if (!onlyIfAbsent)
                                    p.val = value;
                            }
                        }
                    }
                }// 同步代码块结束
                // 操作完成之后判断一下是否需要对链表进行转换为树结构
                if (binCount != 0) {
                    // 如果链表的长度大于等于8，则把链表转换为树
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);// 该方法中有同步代码块来解决并发问题
                    // 如果进入了这个if，则说明之前的put操作成功了
                    if (oldVal != null)// 如果是替换操作则直接返回旧值
                        return oldVal;
                    break;
                }
            }
        }
        // 如果不是替换操作，并且新增元素成功的话就会执行到这里
        // 这里会对node的数据进行统计，如果需要扩容则扩容
        // binCount，如果为0，说明是在空节点新增
        addCount(1L, binCount);
        return null;
    }

2.1 initTable() 初始化Node数组的方法

使用CAS原子修改sizeCtl的值，修改成功的线程才能进行初始化，只会有一个线程能修改成功，其他线程如果发现该值被修改了就会让出CPU，直到Node数组初始化完成后退出该方法。

private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            // 如果sizeCtl小于0则让出cpu（因为已经有线程在进行初始化了）
            // sizeCtl就是初始容量的大小，把它赋值给局部变量sc，sc记录下了容量
            if ((sc = sizeCtl) < 0)
                Thread.yield(); // lost initialization race; just spin
            // 使用cas操作把sizeCtl的值设置为-1，只会有一个线程能设置成功
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {
                try {
                    // 当其他线程也执行到这里的时候，判断table就不为null，会直接返回初始化好的数组
                    if ((tab = table) == null || tab.length == 0) {
                        // sc记录下了容量大小，把容量大小赋值给n，如果在new ConcurrentHashMap的时候没有指定容量，那么这里就使用默认的容量16
                        int n = (sc > 0) ? sc : DEFAULT_CAPACITY;
                        @SuppressWarnings("unchecked")
                        Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n];// 创建出Node数组
                        table = tab = nt;// 将Node数组赋值给table属性
                        sc = n - (n >>> 2);
                    }
                } finally {
                    // 初始化之后，保存要调整表大小的下一个元素计数值。
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

2.2 addCount(long x, int check) 对node的数据进行统计，如果需要扩容则扩容

对Node元素+1成功之后（使用fullAddCount方法CAS操作保证并发安全）计算出当前的Node元素个数；

判断当前元素个数是否达到扩容阈值，如果是则进行扩容；

/**
     * 表初始化和调整大小控件。
     * 当为负数时，表正在初始化或调整大小:-1表示初始化，否则为-(1 +活动调整大小的线程数)。
     * 当表为null时，保存创建时要使用的初始表大小，或默认为0。
     * 初始化之后，保存扩容阈值。
     */
    private transient volatile int sizeCtl;


private final void addCount(long x, int check) {
        CounterCell[] as; long b, s;
        // 如果单元计数器不为空 或者对基础计数器值原子更新失败时 ：if成立
        if ((as = counterCells) != null || !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) {
            CounterCell a; long v; int m;
            boolean uncontended = true;// 默认无竞争
            // ThreadLocalRandom.getProbe()：返回当前线程的探针哈希值
            // 如果单元计数器还没有初始化 或者计数器的长度为0 或者该线程对应的计数元素还没有创建
            if (as == null || (m = as.length - 1) < 0 || (a = as[ThreadLocalRandom.getProbe() & m]) == null ||
                    // CELLVALUE 为CounterCell计数器对象的value值
                    // 获取对计数器对象的原子+1操作失败
                    !(uncontended = U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))) {
                // 总之就是如果统计未成功就执行到这里，然后使用fullAddCount方法来进行统计
                // uncontended：如果原子操作失败则为false，说明有竞争；如果线程计数器对象还没有初始化则默认为true无竞争
                fullAddCount(x, uncontended);
                return;
            }
            if (check <= 1)
                return;
            s = sumCount();// 计算出当前的数据量
        }
        // 对数组进行扩容
        if (check >= 0) {
            Node<K,V>[] tab, nt; int n, sc;
            //检查当前集合元素个数 s 是否达到扩容阈值 sizeCtl ，扩容时 sizeCtl 为负数，依旧成立，
            // 同时还得满足数组非空且数组长度不能大于允许的数组最大长度这两个条件才能继续
            //这个 while 循环除了判断是否达到阈值从而进行扩容操作之外还有一个作用就是当一条线程完成自己的迁移任务后，
            // 如果集合还在扩容，则会继续循环，加入迁移任务
            while (s >= (long)(sc = sizeCtl) && (tab = table) != null && (n = tab.length) < MAXIMUM_CAPACITY) {
                int rs = resizeStamp(n);
                if (sc < 0) {// sc < 0 说明集合正在扩容当中
                    //判断扩容是否结束或者并发扩容线程数是否已达最大值，如果是的话直接结束while循环
                    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);
                }
                //如果集合还未处于扩容状态中，则进入扩容方法，并首先初始化 nextTab 数组，也就是新数组
                else if (U.compareAndSwapInt(this, SIZECTL, sc, (rs << RESIZE_STAMP_SHIFT) + 2))
                    transfer(tab, null);
                s = sumCount();
            }
        }
    }


// See LongAdder version for explanation
    private final void fullAddCount(long x, boolean wasUncontended) {
        int h;
        if ((h = ThreadLocalRandom.getProbe()) == 0) {
            ThreadLocalRandom.localInit(); // 如果为0则需要对这个值进行初始化
            h = ThreadLocalRandom.getProbe();// 获取线程的探针哈希值
            wasUncontended = true;// 如果没有初始化则设置为无竞争
        }
        boolean collide = false;                // True if last slot nonempty
        for (;;) {
            CounterCell[] as; CounterCell a; int n; long v;
            // 如果单元计数器数组已经初始化过了 if成立
            if ((as = counterCells) != null && (n = as.length) > 0) {
                if ((a = as[(n - 1) & h]) == null) {// 判断该线程对应的计数器元素是否为空 如果为空if成立
                    if (cellsBusy == 0) {            // Try to attach new Cell
                        // 创建计数器元素
                        CounterCell r = new CounterCell(x); // Optimistic create
                        if (cellsBusy == 0 && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                            boolean created = false;
                            try {               // Recheck under lock
                                CounterCell[] rs; int m, j;
                                if ((rs = counterCells) != null && (m = rs.length) > 0 && rs[j = (m - 1) & h] == null) {
                                    rs[j] = r;// 将计数器元素赋值到指定下标下
                                    created = true;// 为true下面会跳出循环
                                }
                            } finally {
                                cellsBusy = 0;// 将标记重置为0
                            }
                            if (created)// 赋值操作成功后created为true，跳出循环
                                break;
                            continue;           // Slot is now non-empty
                        }
                    }
                    collide = false;
                }
                else if (!wasUncontended)       // CAS already known to fail
                    wasUncontended = true;      // Continue after rehash
                // 直接对计数器元素的值进行+1操作 如果成功则跳出循环
                else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))
                    break;
                else if (counterCells != as || n >= NCPU)
                    collide = false;            // At max size or stale
                else if (!collide)
                    collide = true;
                // 如果没有其他线程操作 并且原子操作成功（相当于上锁）
                else if (cellsBusy == 0 && U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                    try {
                        if (counterCells == as) {// 检查计数器数组有没有被修改过
                            CounterCell[] rs = new CounterCell[n << 1];
                            for (int i = 0; i < n; ++i)
                                rs[i] = as[i];
                            counterCells = rs;
                        }
                    } finally {
                        cellsBusy = 0;// 置为0（相当于释放锁）
                    }
                    collide = false;
                    continue;                   // Retry with expanded table
                }
                h = ThreadLocalRandom.advanceProbe(h);
            }
            // 如果数组没有被修改并且上锁成功 此分支成立
            else if (cellsBusy == 0 && counterCells == as &&  U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {
                boolean init = false;
                try {                           // Initialize table
                    if (counterCells == as) {// 再次判断
                        CounterCell[] rs = new CounterCell[2];
                        rs[h & 1] = new CounterCell(x);
                        counterCells = rs;
                        init = true;
                    }
                } finally {
                    cellsBusy = 0;// 置为0（相当于释放锁）
                }
                if (init)
                    break;
            }
            // 如果对计数器+1成功则跳出循环
            else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))
                break;                          // Fall back on using base
        }

3，get方法

  1. 根据key计算出hash；
  2. 根据hash计算出数组下标
  3. 如果是链表则遍厉查找，如果是红黑树则调用find方法进行查找
  4. 找到则返回结果，没有找到返回null
public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        int h = spread(key.hashCode());// 计算出数组下标
        // 如果该下标下的元素不为null
        if ((tab = table) != null && (n = tab.length) > 0 && (e = tabAt(tab, (n - 1) & h)) != null) {
            if ((eh = e.hash) == h) {
                // 在头节点找到了key相同的Node，则返回node的value值即可
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            else if (eh < 0)
                // 如果节点的hash值小于0 ，则直接调用node（TreeNode）的查找key节点的方法
                return (p = e.find(h, key)) != null ? p.val : null;
            while ((e = e.next) != null) {// 如果是链表则遍厉查找
                if (e.hash == h && ((ek = e.key) == key || (ek != null && key.equals(ek))))
                    return e.val;
            }
        }
        // 如果都没有找到则返回null
        return null;
    }

4，size方法

调用sumCount方法进行计算

遍厉CounterCell数组，把多个线程在CounterCell数组中统计的数据进行求和，得到总数

public int size() {
        long n = sumCount();
        return ((n < 0L) ? 0 : (n > (long)Integer.MAX_VALUE) ? Integer.MAX_VALUE : (int)n);
    }

final long sumCount() {
        CounterCell[] as = counterCells; CounterCell a;
        long sum = baseCount;
        if (as != null) {
            // 如果单元计数器数组不为空，则遍厉该数组进行统计
            for (int i = 0; i < as.length; ++i) {
                if ((a = as[i]) != null)
                    sum += a.value;
            }
        }
        // 最终返回统计结果
        return sum;
    }

5，remove方法

  1. 根据key找到Node数组对应下标的头元素（如果没有找到则直接返回null）
  2. 对该头元素加锁保证并发安全
  3. 从链表或者红黑树中找到该key的node数据，记录数据后删除，然后维护链表或者红黑树结构
  4. 如果红黑树在删除了一个节点之后node数量小于8，则把红黑树转为链表
  5. 如果删除成功，需要对计数器进行-1操作
  6. 最后返回被删除的值
final V replaceNode(Object key, V value, Object cv) {
        // 根据key计算出hash值
        int hash = spread(key.hashCode());
        for (Node<K,V>[] tab = table;;) {// 死循环
            Node<K,V> f; int n, i, fh;
            // 如果node数组为空，或者该hash对应的数组下标没有数据则跳出循环，最终返回null
            if (tab == null || (n = tab.length) == 0 || (f = tabAt(tab, i = (n - 1) & hash)) == null)
                break;
            // 如果该集合当前正在进行扩容数据迁移则帮助迁移，完成后得到新的node数组数据
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                boolean validated = false;
                // 对hash下标的头元素进行加锁
                synchronized (f) {
                    // 在同步代码块中再次判断头元素是否被修改
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) { // 如果是链表
                            // 遍厉该链表找到需要删除的元素，记录旧值，维护链表结构
                            validated = true;
                            for (Node<K,V> e = f, pred = null;;) {
                                K ek;
                                if (e.hash == hash && ((ek = e.key) == key || (ek != null && key.equals(ek)))) {
                                    V ev = e.val;
                                    if (cv == null || cv == ev ||
                                            (ev != null && cv.equals(ev))) {
                                        oldVal = ev;
                                        if (value != null)
                                            e.val = value;
                                        else if (pred != null)
                                            pred.next = e.next;
                                        else
                                            setTabAt(tab, i, e.next);
                                    }
                                    break;
                                }
                                pred = e;
                                if ((e = e.next) == null)
                                    break;
                            }
                        }
                        // 如果是红黑树，则调用findTreeNode查找元素，记录旧值
                        // 如果删除数据后node数量小于8则恢复为链表结构
                        else if (f instanceof TreeBin) {
                            validated = true;
                            TreeBin<K,V> t = (TreeBin<K,V>)f;
                            TreeNode<K,V> r, p;
                            if ((r = t.root) != null &&
                                    (p = r.findTreeNode(hash, key, null)) != null) {
                                V pv = p.val;
                                if (cv == null || cv == pv ||
                                        (pv != null && cv.equals(pv))) {
                                    oldVal = pv;
                                    if (value != null)
                                        p.val = value;
                                    else if (t.removeTreeNode(p))
                                        setTabAt(tab, i, untreeify(t.first));
                                }
                            }
                        }
                    }
                }
                // 该key对应的元素存在
                if (validated) {
                    if (oldVal != null) {
                        if (value == null)
                            // 对统计数减一
                            addCount(-1L, -1);
                        return oldVal;
                    }
                    break;
                }
            }
        }
        return null;
    }

三、对比

1，并发级别

1.7中使用segment数组来控制并发级别（默认为16）
1.8中使用Node数组的头几点来作为锁对象，并发级别为Node数组的长度，即为Map集合的容量。

2，数据结构

1.7中如果一个Node下标对应了多个数据，则这多个数据的数据结构表现为链表

1.8中如果一个Node下标对应了多个数据，这多个数据的数量如果大于等于8则为红黑树，小于8则为数组。

3，链表的插入

1.7使用头插法

1.8使用尾插法

4，扩容

1.7的扩容是对segment对象中的一小段node数组进行扩容

1.8的扩容是对整个node数组进行扩容，同时支持多线程扩容，并且在扩容的时候没有锁死整个node数组，可以支持部分数据的访问。

 

ns_salulu
关注
专栏目录
【Java并发集合】ConcurrentHashMap源码解析基于JDK1.8
编程小白养成手记
05-21 243
concurrentHashMap（基于jdk1.8） 类注释 所有的操作都市线程安全的，我们在使用时无需进行加锁。 多个线程同时进行put、remove等操作时并不会阻塞，可以同时进行，而HashTable在操作时会锁住整个Map。 在迭代过程中，即使Map及结构被修改，也不会抛出ConcurrentModificationException 。 除了数组+链表+红黑树的基本结构外，新增了转移节点，是为了保证扩容时的线程安全的节点。 提供了很多的Stream方法，比如：foreach、search、re
JDK1.8之ConcurrentHashMap
mmoren的博客
01-25 1883
主要参考：http://www.cnblogs.com/leesf456/p/5453341.html                 http://blog.csdn.net/sunyangwei1993/article/details/77001597 一、前言 　　最近几天忙着做点别的东西，今天终于有时间分析源码了，看源码感觉很爽，并且发现ConcurrentHas
unsafe.compareAndSwapInt aqs
kyomiang的博客
09-18 407
U.compareAndSwapInt(this, CELLSBUSY, 0, 1) this 表示当前对象 CELLSBUSY 偏移量内存地址 0 期望值, 1 更新值 CELLSBUSY = U.objectFieldOffsetk.getDeclaredField("cellsBusy")); 如果 cellsBusy==0 就把内存地址的值改为1 只有一个线程能进入. 此方法是Java的native方法，并不由Java语言实现。 方法的作用是，读取传入对象this在内存中偏移量为CEL...
ConcurrentHashMap源码分析（二）
W1040585666的博客
09-05 678
ConcurrenHashMap 扩容原理解析
Java中CompareAndSwap（CAS）compareAndSwapInt 一些理解，随手记录下
whax
08-21 5129
最近在瞅ConcurrentHashMap源码, CAS的这个方法compareAndSwapInt，有些不是很理解. 虽然知道cas的原理，但是对于这个方法还是比较迷惑，这里随手记录下，查了资料以后的理解。 // 最底层是native方法，那就是C语言实现的,目前没看过C源码，这个坟值得一挖. public final native boolean compareAndSwapInt(Object var1, long var2, int var4, int var5); // 使用就个样子 sun
ConcurrentHashMap1.8 - 扩容详解
y41992910的博客
04-10 6275
简介        ConcurrenHashMap 在扩容过程中主要使用 sizeCtl 和 transferIndex 这两个属性来协调多线程之间的并发操作，并且在扩容过程中大部分数据依旧可以做到访问不阻塞，具体是如何实现的，请继续 。   说明：该源码来自于 jdk_1.8.0_162 版本 。   特别说明：不想看源码可直接跳到后面直接看...
Unsafe.compareAndSwapInt()方法解读
Anakki的博客
08-24 2万+
代码： /** * Atomically update Java variable to <tt>x</tt> if it is currently * holding <tt>expected</tt>. * @return <tt>true</tt> if successful */ public final nat...
java1.8源码-JavaSource:JDK1.8
05-19
在这个"JavaSource:JDK1.8"的源码中，我们可以深入理解Java 8的核心机制和设计理念。下面将详细介绍Java 8的一些关键知识点： 1. **lambda表达式**：Java 8引入了函数式编程的关键特性——lambda表达式，它允许...
Java集合源码深度解析——JDK1.8集合类源码全面讲解
资源摘要信息:"《Java集合源码学习，JDK1.8集合类所有的源码讲解》" Java 集合框架是Java编程语言中非常重要的一部分，它是理解和运用Java进行高效编程的关键技术之一。JDK 1.8作为Java的一个重要版本，其集合框架...
高并发（六）--ConcurrentHashMap 源码解析
m0_52675592的博客
04-26 339
文章目录一. `HashMap`、`HashTable`与`ConcurrentHashMap`的区别JDK1.7中的`ConcurrentHashMap`概述成员变量并发度（Concurrency Level）初始化`put`方法的实现`get`方法的实现`size`方法的实现JDK1.8 `ConcurrentHashMap`讲解`ConcurrentHashMap`相关属性介绍类中相关的节点类：`Node`、`TreeNode`、`TreeBin`、`ForwardingNode`与初始化构造函数初始
compareAndSwapInt实现
kongkong的专栏
03-02 2393
compareAndSwapInt unsafe.compareAndSwapInt(this, valueOffset, expect, update) 接口定义 public final native boolean compareAndSwapInt(Object object, long offset, int expect, int update); unsafe.cpp Unsafe_CompareAndSwapInt UNSAFE_ENTRY(jboolean, Unsafe_Comp
JDK 1.8 ConcurrentHashMap 源码剖析
舒哥的blog
02-04 8842
转载两篇不错的文章： 第一篇： 前言 HashMap是我们平时开发过程中用的比较多的集合，但它是非线程安全的，在涉及到多线程并发的情况，进行put操作有可能会引起死循环，导致CPU利用率接近100%。 final HashMapString, String> map = new HashMapString, String>(2); for (int i = 0; i 10000
cas cpu 硬件同步原语(compare and swap)
zdy0_2004的专栏
11-07 2260
cas 分类： linux api2012-07-04 11:16 311人阅读 评论(0) 收藏 举报 算法linux内核structjni汇编google 在JDK 5之前Java语言是靠synchronized关键字保证同步的，这会导致有锁（后面的章节还会谈到锁）。 锁机制存在以下问题： （1）在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，
ConcurrentHashmap的fullAddCount
luzhensmart的专栏
05-06 1445
fullAddCount主要是用来初始化CounterCell，来记录元素个数，里面包含扩容，初始化等操作 private final void fullAddCount(long x, boolean wasUncontended) { int h; //获取当前线程的probe的值，如果值为0，则初始化当前线程的probe的值,probe就是随机数 ...
并发实战——原子类AtomicReference及底层源码CompareAndSwapObject分析
qqqqq1993qqqqq的博客
07-16 1万+
本文内容： 分析原子类AtomicReference 分析源码 AtomicReference中public final boolean compareAndSet(V expect, V update) { return unsafe.compareAndSwapObject(this, valueOffset, expect, update); }public final
关于jdk1.8中ConcurrentHashMap的方方面面
不若乘风来
10-11 3万+
前言 Java JDK升级到1.8后有些集合类的实现有了变化，其中ConcurrentHashMap就有进行结构上的大调整。jdk1.6、1.7实现的共同点主要是通过采用分段锁Segment减少热点域来提高并发效率，1.8版本的实现有哪些变化呢？ 重要概念 在正式研究前，我们需要先知道几个重要参数，提前说明其值所代表的意义以便更好的讲解源码实现。 table 所有数据都存在tab...
知识图谱整理之Java基础ConcurrentHashMap
知足happiness的博客
09-28 178
ConcurrentHashMap介绍 ConcurrentHashMap是在Java并发包下的一个类，它的作用和HashMap类似，不过做了线程安全的防护，支持并发操作。 本文分析的也是基于JDK1.8的 数据存储结构 我们直接来看下源码会比较直观： static class Node<K,V> implements Map.Entry<K,V> { f...
ConcurrentHashMap源码解析（jdk1.8）
热门推荐
programmer_at的专栏
03-27 4万+
ConcurrentHashMap 基于JDK1.8 ConcurrentHashMap 1. 原理解析 1.1. 重要成员变量 1.2. 实例初始化 1.3. put操作 1.3.1 put过程描述 1.3.2 hash算法 1.3.3 定位索引 1.3.4 获取table对应的索引元素f 1.4. table 扩容 1.4.1 addCount 1.4.2 treeify ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值