并发编程19

最新推荐文章于 2022-02-16 13:58:57 发布
最新推荐文章于 2022-02-16 13:58:57 发布
阅读量170 收藏
点赞数 1
分类专栏： 并发编程 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Markland_l/article/details/112856672
版权
本文深入探讨了HashMap和ConcurrentHashMap的实现原理，包括ArrayList和LinkedList的基础，以及HashMap如何结合二者特性。重点分析了ConcurrentHashMap的初始化、扩容策略、线程安全的实现，特别是其在多线程环境下的putVal和transfer方法。文章还揭示了sizeCtl参数的重要性，并详细解释了扩容过程中的数据迁移逻辑。
摘要由CSDN通过智能技术生成

并发编程19

HashMap

  • 掌握map首先要掌握list的原理

ArrayList源码

  • add方法，首先判断是否装满，装满了，则扩容，没装满则直接添加，实际就是操作数组

LinkedList源码

  • 比ArrayList要复杂，是以链表实现的，每一个节点都是一个Node类，是双向链表

  • class Node<T>{
    Node pre;
    T t;
    Node next;
}

  • add方法

    • 首先创建Node对象，如果头节点是空的，则设置头节点，同时尾节点也是添加的第一个节点
    • 创建第二个节点时，首先把头节点设置成这个新节点的前一个节点，同时对这个新节点赋值，然后再把第一个节点的下一个节点设置为这个新节点，同时令尾节点等于新节点

HashMap源码

  • 是ArrayList和LinkedList的组合
  • 像ArrayList那样，但是每一个数组元素都是一个Entry，而entry是继承了键值对属性的Node，而Node可以看做LinkedList，键值对中的key，存放的是hash值。

ConcurrentHashMap源码

一个坑

  • new时传入容量大小是32，但是真正的初始容量是64？

  • jdk1.7中32就是32，jdk1.8中32就是64

  • hashMap你指定容量大小是多少就是多少，不管jdk版本

  • public ConcurrentHashMap(int initialCapacity) {
    if (initialCapacity < 0)
        throw new IllegalArgumentException();
     // jdk1.8初始化大小是（执定值+ 执定值/2 +1) 的最大最近的2的幂次方   tableSizeFor:输入低于最大容量的数c，返回大于等于且最接近c的2的幂次数。
    int cap = ((initialCapacity >= (MAXIMUM_CAPACITY >>> 1)) ?
               MAXIMUM_CAPACITY :
               tableSizeFor(initialCapacity + (initialCapacity >>> 1) + 1));  
    this.sizeCtl = cap;
}

sizeCtl

  • // sizeCtl这个参数很重要
// sizeCtl为0 代表数组没有初始化
// sizeCtl为正数 数组已经初始化，记录的是数组的扩容阈值，如果没有初始化，记录的是数组初始容量
// sizeCtl 为-1 代表数组正在初始化
// sizeCtl 为负数，并且不是-1，表示数组正在扩容

putVal

  • final V putVal(K key, V value, boolean onlyIfAbsent) {
    if (key == null || value == null) throw new NullPointerException();
    // 算出hash值   这个值一定是个正数      0x7fffffff; 
    // f的二进制为：1111，7的二进制位0111  换算完之后最高位为0，所以最终值肯定为正数，最高位为0，无论怎么与，算出都是0，所以肯定是正数
    int hash = spread(key.hashCode());  
    int binCount = 0;
    // 是一个死循环
    // table是node<k,v>数组
    // 由于里面都是else if，第一个线程创建完数组后，又会再次进入for循环
    for (Node<K,V>[] tab = table;;) {
        Node<K,V> f; int n, i, fh;
        // 第一个线程进来的第一次添加必然为true
        if (tab == null || (n = tab.length) == 0)  
            // 创建数组
            // 添加的时候才会去初始化数组
            tab = initTable();   
        // 拿出次key hash位置的value，如果为空则去添加
        // tabAt方法---可以认为是随机取出这个数组里面的一个值（通过哈希算法）
        // 此时刚刚创建也是null的
        else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {   
            // 判断这个hash位置的内存中的值是否为null，如果真为null，则把新建的Node赋值给它
            // 如果此时有别的线程也hash出来是在相同的数组位置，此时cas不成功
            if (casTabAt(tab, i, null,
                         new Node<K,V>(hash, key, value, null)))
                break;                   // no lock when adding to empty bin
        }
        // 如果此判断成立  说明此数组正在扩容，则去协助扩容
        // 扩容时，迁移完成的数组某个位置会加个MOVED(-1)
        else if ((fh = f.hash) == MOVED)   
            // 多线程扩容
            tab = helpTransfer(tab, f);
        else {
            // 如果hash算出来的数组位置相同，并且有值，就会进入这里
            V oldVal = null;
            // 锁住此位置
            // 只锁住加入的数组中的某个位置
            // 而hashTable是锁住整个数组
            synchronized (f) {     
                // 双重检验，如果红黑树改变掉了，锁就无效了
                // 再次判断是因为  此位置的value有可能变为红黑树，锁就没用了
                if (tabAt(tab, i) == f) {  
                    // 如果成立说明是链表
                    // 数组中的元素除了是链表，也有可能是红黑树
                    if (fh >= 0) {     
                        binCount = 1;
                        // f是当前添加的数组中的对象
                        for (Node<K,V> e = f;; ++binCount) {
                            K ek;
                            // 如果hash和key都一样，并且非空
                            if (e.hash == hash &&
                                ((ek = e.key) == key ||
                                 (ek != null && key.equals(ek)))) {    
                                oldVal = e.val;
                                // onlyIfAbsent
                                // 如果key相同是否覆盖旧值
                                // 默认是覆盖
                                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)   
                    //但是如果数组的长度小于64，那么则不变为红黑树，则扩容
                    treeifyBin(tab, i);    
                if (oldVal != null)
                    return oldVal;
                break;
            }
        }
    }
    // 维护集合长度，判断是否达到扩容阈值，如果是，则扩容
    // binCount表示的是当前加入数组所在位置的链表长度
    addCount(1L, binCount);  
    return null;
}

initTable

  • // 可以实现无锁的并发
private final Node<K,V>[] initTable() {
        Node<K,V>[] tab; int sc;
        while ((tab = table) == null || tab.length == 0) {
            // sizeCtl小于0，代表 数组正在初始化或者正在扩容
            // 如果传了是最接近的2的n次幂，不传是0，所以第一次进来不成立
            if ((sc = sizeCtl) < 0) 
                // 会把CPU时间让掉，让其他或者自己的线程执行（也就是谁先抢到谁执行）
                // 即使抢到了，也没有执行创建数组的操作
                Thread.yield(); 
            // compareAndSwapInt(Object var1, long var2, int var4, int var5);
            // o：目标Java变量引用。offset：目标Java变量中的目标属性的偏移地址。expected：目标Java变量中的目标属性的期望的当前值。x：目标Java变量中的目标属性的目标更新值。
            // SIZECTL就是sizeCtl的内存地址，绕过jvm直接从内存拿值
            else if (U.compareAndSwapInt(this, SIZECTL, sc, -1)) {      
                try {
                    // 双重判断是为了不重复创建 因为一个线程创建完后，会更改sizeCtl值
                    // cas改为-1时，其余的线程都会在上面阻塞，创建为数组后，此时已经变成大于0的数，又会再次进入else if，防止重复创建
                    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;
                        // 可以换算为 n*0.75   n >>> 2= 四分之一  ，此时sizeCtl=扩容阈值
                        // sc = n-0.25n = 0.75*n
                        // 为什么是0.75作为扩容阈值？
                        sc = n - (n >>> 2);    
                    }
                } finally {
                    sizeCtl = sc;
                }
                break;
            }
        }
        return tab;
    }

addCount

  • // 计数的方式有两种
// 一是baseCount
// 二是一个数组，多线程加结果可能不对
private final void addCount(long x, int check) {
    CounterCell[] as; long b, s;
    // 首先加baseCount
    // 加baseCount成功不会进入  加baseCount失败则进入
    // counterCells就是计数的数组
    if ((as = counterCells) != null ||
        !U.compareAndSwapLong(this, BASECOUNT, b = baseCount, s = b + x)) 
    // 如果多线程cas更新失败则进入if
    {   
        CounterCell a; long v; int m;
        boolean uncontended = true;
        // 并发时更新失败进来的第一个线程，as肯定是空的，如果进入if
        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;
        // 算出当前map中有多少元素，判断是否达到扩容阈值，如果是，则扩容
        // 把baseCount和计数数组里面的值全部累加起来
        s = sumCount();   
    }
    // 判断要不要扩容
    // 扩容是最难的
    if (check >= 0) {
        Node<K,V>[] tab, nt; int n, sc;
        while (s >= (long)(sc = sizeCtl) && (tab = table) != null &&
               (n = tab.length) < MAXIMUM_CAPACITY) {
            //创建一个标识值
            int rs = resizeStamp(n);    
            //第一个线程进来不可能小于0
            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 改为一个负数
            else if (U.compareAndSwapInt(this, SIZECTL, sc,    
                                         (rs << RESIZE_STAMP_SHIFT) + 2))
                //发起扩容（只有可能是第一个线程执行）
                transfer(tab, null);   
            s = sumCount();
        }
    }
}

fullAddCount

  • private final void fullAddCount(long x, boolean wasUncontended) {
    int h;
    //以此线程生成一个随机数，作为数组下标
    if ((h = ThreadLocalRandom.getProbe()) == 0) {     
        ThreadLocalRandom.localInit();      // force initialization
        h = ThreadLocalRandom.getProbe();
        wasUncontended = true;
    }
    boolean collide = false;                // True if last slot nonempty
    for (;;) {
        CounterCell[] as; CounterCell a; int n; long v;
        // 第一次进来肯定为false（一旦有线程进入，则为true，那么数组已经创建），执行下面的else if
        // 第二次进来，不为null
        if ((as = counterCells) != null && (n = as.length) > 0) {    
            // 随机取值，如果为空，则赋值
            if ((a = as[(n - 1) & h]) == null) {       
                if (cellsBusy == 0) {            // Try to attach new Cell
                    CounterCell r = new CounterCell(x); // Optimistic create
                    // 此处的U.compareAndSwapInt(this, CELLSBUSY, 0, 1)可以认为是一个锁
                    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) {
                                // 赋值给计数数组，直接放个1
                                rs[j] = r;
                                created = true;
                            }
                        } finally {
                            cellsBusy = 0;
                        }
                        if (created)
                            break;
                        continue;           // Slot is now non-empty
                    }
                }
                collide = false;
            }
            else if (!wasUncontended)       // CAS already known to fail
                wasUncontended = true;      // Continue after rehash
            // 此数组已经有值，那么直接累加---累加操作
            else if (U.compareAndSwapLong(a, CELLVALUE, v = a.value, v + x))   
                break;
            // 避免数组扩容，当目前的数组长度>=CPU核数时
            // 此处的扩容是指对计数数组进行扩容
            // 如果n>=NCPU，只加一次自旋次数？
            // 如果数组数已经大于核心数(并行数)，就没有必要对计数数组进行扩容了
            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) {// Expand table unless stale
                        CounterCell[] rs = new CounterCell[n << 1];
                        for (int i = 0; i < n; ++i)
                            rs[i] = as[i];
                        counterCells = rs;
                    }
                } finally {
                    cellsBusy = 0;
                }
                collide = false;
                continue;                   // Retry with expanded table
            }
            h = ThreadLocalRandom.advanceProbe(h);
        }
        // 创建计数数组，并且赋值（并发cas更新失败进来的第一个线程）
        else if (cellsBusy == 0 && counterCells == as &&
                 U.compareAndSwapInt(this, CELLSBUSY, 0, 1)) {      
            boolean init = false;
            try {                           // Initialize table
                // 双重校验，不重复创建
                if (counterCells == as) {
                    // 创建了一个数组大小为2的数组---counterCells
                    // 其中一个是1，一个是空
                    CounterCell[] rs = new CounterCell[2];
                    rs[h & 1] = new CounterCell(x);
                    counterCells = rs;
                    init = true;
                }
            } finally {
                cellsBusy = 0;
            }
            if (init)
                break;
        }
        //数组正在创建  对baseCount++
        else if (U.compareAndSwapLong(this, BASECOUNT, v = baseCount, v + x))   
            break;                          // Fall back on using base
    }
}

transfer

  • private final void transfer(Node<K,V>[] tab, Node<K,V>[] nextTab) {
    int n = tab.length, stride;
    // 因为是多线程扩容
    // 判断每一个线程要领多少个任务
    // stride是每一个线程要迁移多少个值
    // 单线程也是分段，一段一段来迁移的
    // 多线程扩容，每个线程最少领16个格子
    if ((stride = (NCPU > 1) ? (n >>> 3) / NCPU : n) < MIN_TRANSFER_STRIDE)
        // stride肯定大于16
        stride = MIN_TRANSFER_STRIDE; 
    // initiating
    if (nextTab == null) {            
        try {
            @SuppressWarnings("unchecked")
            Node<K,V>[] nt = (Node<K,V>[])new Node<?,?>[n << 1];
            nextTab = nt;
        } catch (Throwable ex) {      // try to cope with OOME
            sizeCtl = Integer.MAX_VALUE;
            return;
        }
        //创建的新数组（老数组的两倍）
        nextTable = nextTab;   
        //老数组的长度
        transferIndex = n;   
    }
    //新数组长度
    int nextn = nextTab.length;  
    ForwardingNode<K,V> fwd = new ForwardingNode<K,V>(nextTab);
    boolean advance = true;
    // 所有线程是否完成扩容
    boolean finishing = false; 
    for (int i = 0, bound = 0;;) {
        Node<K,V> f; int fh;
        //计算迁移多少
        while (advance) {               
            int nextIndex, nextBound;
            if (--i >= bound || finishing)
                advance = false;
            else if ((nextIndex = transferIndex) <= 0) {
                i = -1;
                advance = false;
            }
            //将transferIndex设置为 老数组的长度-16 或者 0
            else if (U.compareAndSwapInt
                     (this, TRANSFERINDEX, nextIndex,
                      nextBound = (nextIndex > stride ?
                                   nextIndex - stride : 0))) {  
                //老数组的长度-16 或者 0
                bound = nextBound;  
                //老数组的长度-1 
                i = nextIndex - 1;  
                //结束当次循环
                advance = false;   
            }
        }
        //判断是否扩容完成
        if (i < 0 || i >= n || i + n >= nextn) {    
            int sc;
            if (finishing) {
                nextTable = null;
                table = nextTab;
                sizeCtl = (n << 1) - (n >>> 1);
                return;
            }
            //判断所有线程是否完成扩容
            if (U.compareAndSwapInt(this, SIZECTL, sc = sizeCtl, sc - 1)) {   
                if ((sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT)
                    return;
                finishing = advance = true;
                i = n; // recheck before commit
            }
        }
        //如果当前位置为空  那么赋值fwd
        else if ((f = tabAt(tab, i)) == null)   
            advance = casTabAt(tab, i, null, fwd);
        //如果已经迁移完成了 那么什么都不干
        else if ((fh = f.hash) == MOVED)      
            advance = true; // already processed
        else {
            //防止迁移的时候  别的线程加数据
            synchronized (f) {    
                if (tabAt(tab, i) == f) {
                    Node<K,V> ln, hn;
                    if (fh >= 0) {
                        int runBit = fh & n;
                        // 重点
                        // 区别数据 假设现在迁移的位置 是个链表 size是6  那么可能还是3个保留在原来的位置  还有3个放置到原来的位置+老数组的长度位置上
                        Node<K,V> lastRun = f;
                        for (Node<K,V> p = f.next; p != null; p = p.next) {
                            int b = p.hash & n;
                            if (b != runBit) {
                                runBit = b;
                                lastRun = p;
                            }
                        }
                        if (runBit == 0) {
                            ln = lastRun;
                            hn = null;
                        }
                        else {
                            hn = lastRun;
                            ln = null;
                        }
                        for (Node<K,V> p = f; p != lastRun; p = p.next) {
                            int ph = p.hash; K pk = p.key; V pv = p.val;
                            if ((ph & n) == 0)
                                ln = new Node<K,V>(ph, pk, pv, ln);
                            else
                                hn = new Node<K,V>(ph, pk, pv, hn);
                        }

                        setTabAt(nextTab, i, ln);
                        setTabAt(nextTab, i + n, hn);
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }
                    else if (f instanceof TreeBin) {
                        TreeBin<K,V> t = (TreeBin<K,V>)f;
                        TreeNode<K,V> lo = null, loTail = null;
                        TreeNode<K,V> hi = null, hiTail = null;
                        int lc = 0, hc = 0;
                        for (Node<K,V> e = t.first; e != null; e = e.next) {
                            int h = e.hash;
                            TreeNode<K,V> p = new TreeNode<K,V>
                                (h, e.key, e.val, null, null);
                            if ((h & n) == 0) {
                                if ((p.prev = loTail) == null)
                                    lo = p;
                                else
                                    loTail.next = p;
                                loTail = p;
                                ++lc;
                            }
                            else {
                                if ((p.prev = hiTail) == null)
                                    hi = p;
                                else
                                    hiTail.next = p;
                                hiTail = p;
                                ++hc;
                            }
                        }
                        ln = (lc <= UNTREEIFY_THRESHOLD) ? untreeify(lo) :
                        (hc != 0) ? new TreeBin<K,V>(lo) : t;
                        hn = (hc <= UNTREEIFY_THRESHOLD) ? untreeify(hi) :
                        (lc != 0) ? new TreeBin<K,V>(hi) : t;
                        setTabAt(nextTab, i, ln);
                        setTabAt(nextTab, i + n, hn);
                        setTabAt(tab, i, fwd);
                        advance = true;
                    }
                }
            }
        }
    }
}

  • // 重点

  • // 区别数据 假设现在迁移的位置 是个链表 size是6 那么可能还是3个保留在原来的位置 还有3个放置到原来的位置+老数组的长度位置上

  • // 把链表长度变短

  • Node<K,V> lastRun = f;
for (Node<K,V> p = f.next; p != null; p = p.next) {
    int b = p.hash & n;
    if (b != runBit) {
        runBit = b;
        lastRun = p;
    }
}
if (runBit == 0) {
    ln = lastRun;
    hn = null;
}
else {
    hn = lastRun;
    ln = null;
}
for (Node<K,V> p = f; p != lastRun; p = p.next) {
    int ph = p.hash; K pk = p.key; V pv = p.val;
    if ((ph & n) == 0)
        ln = new Node<K,V>(ph, pk, pv, ln);
    else
        hn = new Node<K,V>(ph, pk, pv, hn);
}

setTabAt(nextTab, i, ln);
setTabAt(nextTab, i + n, hn);
setTabAt(tab, i, fwd);
advance = true;

  • // (resizeStamp(n) << RESIZE_STAMP_SHIFT) + 2)
// (sc - 2) != resizeStamp(n) << RESIZE_STAMP_SHIFT
Markland_l
关注
专栏目录
Map源码解析之ConcurrentHashMap(JDK1.8)(二)
翻身已碰头的博客
03-08 652
Map源码解析之HashMap Map源码解析之HashMap红黑树 Map源码解析之HashMap补充：集合、迭代器、compute、merge、replace Map源码解析之LinkedHashMap Map源码解析之TreeMap Map源码解析之HashTable Map源码解析之ConcurrentHashMap(JDK1.8)(一) 本篇文章将在 Map源码解析之Concurren...
ConcurrentHashMap源码解读
x_h_xx的博客
05-27 305
CHM put方法 1.检查key和value不为null 2.计算hash值 int hash = spread(key.hashCode()); // key.hashCode() = h ,(h ^ (h >>> 16)) & HASH_BITS 3.自旋插入 int binCount = 0; Node<K, V>[] tab = table //将全局table赋值tab 4.初始化table if (tab == null ..
ConcurrentHashMap实现原理及源码阅读
qq_41011723的博客
05-03 261
可访问个人网站进行阅读最新版本，精力有限无法多网站同步更新，更新只会在个人网站进行 参考自 https://ddnd.cn/2019/03/10/jdk1-8-concurrenthashmap/ https://juejin.im/post/5c8276216fb9a049d51a4cd6 面试题 并发安全机制 分段锁机制 synchronized + CAS 内部数据结构 一、了解Ha...
ConcurrentHashMap源码分析
Apple_Andy的博客
02-07 240
一、jdk1.8容器初始化 1、源码分析 在jdk8的ConcurrentHashMap中一共有5个构造方法，这五个构造方法中都没有对内部的数组做初始化， 只是对一些变量的初始值做了处理 //没有维护任何变量的操作，如果调用该方法，数组长度默认是16 public ConcurrentHashMap() { } 注意，调用可以传递初始容量的构造方法，得到的初始容量和HashMap以及jdk7的ConcurrentHashMap不同，即使你传递的是一个2的幂次方数，该方法计算出来的初始容量依然是
ConcurrentHashMap的sizeCtl含义纠正
Unknownfuture的博客
04-06 8715
引言： 本文基于JDK1.8版本，而且对ConcurrentHashMap有一定了解的人，本文并非科普该类的用法，而是针对sizeCtl的含义做出纠正 科普文章推荐： 深入浅出ConcurrentHashMap1.8 sizeCtl定义及注释 /** * Table initialization and resizing control. When negative, the ...
java并发编程实战源码,java并发编程实战pdf,Java
09-10
《Java并发编程实战》是Java并发编程领域的一本经典著作，它深入浅出地介绍了如何在Java平台上进行高效的多线程编程。这本书的源码提供了丰富的示例，可以帮助读者更好地理解书中的理论知识并将其应用到实际项目中。...
java并发编程实践pdf笔记
最新发布
12-15
Java并发编程实践是Java开发中不可或缺的一个领域，它涉及到如何高效、正确地处理多线程环境中的任务。这本书的读书笔记涵盖了多个关键知识点，旨在帮助读者深入理解Java并发编程的核心概念。 1. **线程和进程的...
Java高并发编程，构建并发编程知识体系，提升面试成功率
09-23
Java高并发编程，构建并发编程知识体系，提升面试成功率，完整版17章视频教程下载。 本课程将结合大量图示及代码演示，带你掌握多线程并发编程（线程安全，线程调度，线程封闭，同步容器等）与高并发处理思路与手段...
Java 并发编程实战.pdf
05-28
《Java并发编程实战》这本书是关于Java语言中并发编程技术的经典著作。它详细介绍了如何在Java环境中有效地实现多线程程序和并发控制机制。在Java平台上，由于其本身提供了强大的并发编程支持，因此，掌握并发编程...
java并发编程实战源码-jcip-examples:java并发编程实战
05-25
《Java并发编程实战》是Java并发编程领域的一本经典之作，由Brian Goetz等作者撰写。这本书深入浅出地介绍了Java并发编程的各种概念和技术，帮助开发者理解和掌握如何在多线程环境中编写高效、安全的代码。jcip-...
Java并发编程|第十篇：ConcurrentHashMap源码分析
谢文峰的博客
12-27 405
Java并发编程|第十篇：ConcurrentHashMap源码分析 文章目录Java并发编程|第十篇：ConcurrentHashMap源码分析前言1.介绍2.例子3.JDK1.7 和 JDK1.8 的区别JDK1.7JDK1.84.源码分析put方法初始化阶段initTable()sizeCtl值的含义tabAt()casTabAt()put方法集合大小计算阶段addCount()Counte...
关于hashmap与并发map（Currenthashmap）面试题 二
weixin_44708180的博客
02-16 809
内容较多 但都是并发map的 核心 耐心看完
ConcurrentHashMap扩容？lastRun到底是个啥？（普通链表）
牧夏的个人博客
03-24 8055
文章目录问题一：第一个for循环什么意思？问题二：第二个for循环中为什么以lastRun作为结束标志？问题三：lastRun到底十个什么？为什么不用在第二个循环里放？我不放的话，在哪里把lastRun后面的放到低位链或者高位链？总结连接 这一小段看了两个小时！CHM看到如下这段代码给我干蒙了，我是真的菜，感觉自己没有智商~ 这段代码是CHM扩容中的普通链表扩容，看完之后这个人都不一样了，Dou...
ConcurrentHashMap源码分析（JDK1.8）
ji1162765575的博客
12-24 414
一、JDK1.8ConcurrentHashMap介绍 JDK1.8中ConcurrentHashMap底层依旧是数组+链表+红黑树，使用Synchronized+CAS来保证线程安全 几个默认值 DEFAULT_INITIAL_CAPACITY 默认初始化容量 16 MAXIMUM_CAPACITY 最大容量 2的30次幂 DEFAULT_LOAD_FACTOR 默认的负载因子 0.75 DEFAULT_CONCURRENCY_LEVEL 并发等级 16 sizeCtl介绍 用来控制table的初
sizeCtl含义
qq_39492864的博客
08-08 997
sizeCtl为0，代表数组未初始化，且数组的初始容量为16 sizeCtl为正数，如果数组未初始化，纪录数组的初始容量，如果已初始化，纪录的是数组的扩容阈值 sizeCtl为-1表示正在进行初始化 sizeCtl小于0但不是-1表示数组正在扩容，-（1+n）表示有n个线程正在共同完成扩容操作。 ...
JUC源码解析-ConcurrentHashMap1.8
业精于勤荒于嬉 行成于思毁于随
06-14 6824
前言 1.8后的ConcurrentHashMap与之前有截然不同的设计，之前是分段锁的思想，通过采用分段锁Segment减少热点域来提高并发效率。1.8利用CAS+Synchronized来保证并发更新的安全，底层采用数组+链表+红黑树的存储结构。 在此再一次膜拜Doug Lea大神，高山仰止。1.8的ConcurrentHashMap有6313行代码，之前大概是1000多行。 这篇文章也...
阿里面试题多线程打印问题
Markland_l的博客
02-06 1340
package bingFaBianCheng17; import java.sql.Connection; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; public class test8 { static boolean a = false; static boo
并发编程5
Markland_l的博客
01-31 551
synchronized关键字原理 回顾 公平锁和非公平锁的区别（acquire方法和tryAcquire方法都不同） 区别一：首先非公平锁直接去cas尝试获取锁，如果获取锁失败，再执行非公平锁版的acuqire()方法，而公平锁会直接执行公平锁版的acquire方法 如果非公平锁获取锁失败，也就是两者都去执行tryAcquire方法 如果c！=0（这把锁没被人持有），后面执行的方法是一样的 区别二：如果c==0（这把锁被人持有），多执行了一个hasQueuedPredecessors方法
并发编程6
Markland_l的博客
02-02 366
锁的膨胀过程2 重偏向不同于锁重入 重偏向是第一次偏向锁已经释放了，再一次加偏向锁，就是一个代码块里有两个相邻的synchronized块 锁重入就是synchronized里面再套一个synchronized 一个线程进入synchronized并退出后对象头的变化 轻量锁加锁有个前置的逻辑 首先第一个线程获取锁成功后，对象头改为：线程id+101 当这个线程执行完退出synchronized块后，对象头改为：000…0001 synchronized源码分析 并发编程5中用到的openjdk
Java并发编程深度解析
"Java并发编程-方腾飞魏鹏程晓明著" Java并发编程是Java开发中的重要主题，尤其对于大型企业级应用和分布式系统来说，理解并熟练掌握并发编程技术至关重要。阿里技术专家团队编写的《Java并发编程的艺术》详细探讨...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值