hashmap自己解读(外加红黑树+ConcurrentHashMap)

ConcurrentHashMap源码解读! 1 .首先先看看为什么要使用ConcurrentHashMap! 首先,ConcurrentHashMap是JDK5中引用的一个线程安全的支持高并发的HashMap集合类。它是弥补了HashMap和HashTable的不足而设计的; 1.HashMap是非线程安全的,在多线程操作环境下,使用Hashmap进行put操作可能会引起死循环,导致CPU利用率接近100%,所以在并发情况下一般不使用Has... 阅读详情

开头

借用网友的图片,这是hashmap的整体结构,数组+链表(jdk>1.8时加入红黑树)
请添加图片描述
本文使用的jdk版本为1.8.0_301,内容较jdk1.7版本改变很大
看文章的时候不建议完全看我的注释,建议先自己分析,遇到卡壳的地方来看一下(我也是这么学的)。
看的话,建议从头到尾看,因为开头写的比较详细
关于HashMap的基础部分,看看这个挺好的
https://zhuanlan.zhihu.com/p/127147909

HashMap类

hash方法

	//根据key,算出hash值,后续将hash%n得到key在数组中的位置
    static final int hash(Object key) {
        int h;
        //key.hashCode(),每个基本类型实现了自己的hashCode方法,比如String.hashCode(),可以自己去看一看
        //java中>>>代表无符号右移,忽略符号位,空位都以0补齐
        //h^(h>>>16)是h的低16位和高16位相与。如果容量不大很少用到hash的高位,这里均衡用了一下
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

总结:
1.设置的key需要实现hashCode方法
2.hashmap中最终的hash是高16位和低16位相与的结果

put方法

    public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //(n-1)&hash = hash%n 其中n是数组的长度,也就是说通过hash定位到数组中的位置
        //对计算机来说,&操作相比%时间更短
        if ((p = tab[i = (n - 1) & hash]) == null)
        	//数组中没有值就插入一个新的Node
            tab[i] = newNode(hash, key, value, null);
        //发生hash碰撞,解决
        else {
            Node<K,V> e; K k;
            //p为原数组中的结点,与新加进来的结点进行比较:
            //hash相同,同时key也完全相同,则把当前结点负值给临时变量e,后续修改value
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            //如果原结点p,已经是红黑树的结点,那么就将当前结点加入到p所在的红黑树中,e作为返回值
            else if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //否则既不是原结点修改value也不是红黑树,则为添加到链表中,同时进行计数
            //如果加入后节点值>=8则转换为红黑树
            //如果在链表中找到了key相同的结点,进行value替换
            else {
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                    	//添加到空结点的后面
                        p.next = newNode(hash, key, value, null);
                        //计数超过8-1,则链表转化成红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash);
                        break;
                    }
                    //遍历链表途中是否找到相同的key,找到就返回
                    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;
            }
        }
        //命中为空,则为修改hashmap的结构,修改计数加一
        ++modCount;
        //修改结构后判断大小,是否进行resize
        if (++size > threshold)
            resize();
        //Callbacks to allow LinkedHashMap post-actions
        afterNodeInsertion(evict);
        return null;
    }

总结
put分为两种:
1.命中hashmap中的某个key,则修改value
2.未命中,添加结点。添加结点时如果总结点数大于8,并且数组长度大于64会将链表转化成红黑树
如果节点数大于8,但是数组长度小于64,会先考虑扩容。因为hash在小于64的时候效率最高

get方法

    public V get(Object key) {
        Node<K,V> e;
        return (e = getNode(hash(key), key)) == null ? null : e.value;
    }
	final Node<K,V> getNode(int hash, Object key) {
        Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            //数组中存在hash相同
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;
            if ((e = first.next) != null) {
            	//红黑树中查找
                if (first instanceof TreeNode)
                    return ((TreeNode<K,V>)first).getTreeNode(hash, key);
                do {
                	//链表中查找
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        return e;
                } while ((e = e.next) != null);
            }
        }
        return null;
    }

总结
1.数组中结点是否命中
2.判断是否是红黑树,并查找结点
3.链表中查找结点

resize方法

    final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //threshold表示当HashMap的size大于threshold时会执行resize操作。
		//threshold=capacity*loadFactor
		//在HashMap初始化的时候如果填写初始化容量initialCapacity,则会初始化threshold,值为this.threshold = tableSizeFor(initialCapacity);否则threshold的值为0
		//后文称之为扩容阈值
        int oldThr = threshold;
        int newCap, newThr = 0;
        //旧容量大于0
        if (oldCap > 0) {
        	//旧数组容量已经大于最大容量了,阈值设置到更大, 
        	//HashMap.MAXIMUM_CAPACITY = 1 << 30 值为0x40000000
        	//Integer.MAX_VALUE = 0x7fffffff
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //旧数组容量扩大二倍还没到最大容量,就把数组扩大二倍,同时阈值扩大二倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //表示旧容量是0 但是旧阙值却大于零,就扩容新的容量为旧的阈值
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        //旧容量为0 旧阈值为0 则初始化
        else {               // zero initial threshold signifies using defaults
        	//初始容量  1<<4
            newCap = DEFAULT_INITIAL_CAPACITY;
            //初始阈值  1<<4 * 0.75
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        //新阈值为0时,设置新阈值为新容量 * 新加载因子
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            //考虑到新容量或者新阈值是否比最大容量大,如果是的话,设置最大容量为0x7fffffff
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        //扩容结束
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        //重新建立hash数组
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //e没有下一个结点,就老哥一个,直接重新散列
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    //如果在旧哈希表中,这个位置是树形的结果,就要把新hash表中也变成树形结构
                    //通过split函数进行拆分
                    else if (e instanceof TreeNode)
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    //链表的情况赋值给new tab
                    else { // preserve order
                    	//下面算法很微妙
                    	//定义两个链表lo和hi,分别设置头指针和尾指针
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                        do {
                            next = e.next;
                            //将原链表拆分成两个链表
                            //根据(e.hash & oldCap) == 0来区分是加入lo链表还是hi链表
                            //扩容2倍后Node要么添加在j上,要么添加在j+oldCap上具体原理,参考
                            //https://segmentfault.com/a/1190000015812438
                            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);
                        //如果lo链表非空, 我们就把整个lo链表放到新table的j位置上
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        //如果hi链表非空, 我们就把整个hi链表放到新table的j+oldCap位置上
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }

总结
resize发生在table初始化, 或者table中的节点数超过threshold值的时候, threshold的值一般为负载因子乘以容量大小.
每次扩容都会新建一个table, 新建的table的大小为原大小的2倍.
扩容时,会将原table中的节点re-hash到新的table中, 但节点在新旧table中的位置存在一定联系: 要么下标相同, 要么相差一个oldCap(原table的大小).
这也是cap为2的倍数的好处之一

remove方法

    public V remove(Object key) {
        Node<K,V> e;
        return (e = removeNode(hash(key), key, null, false, true)) == null ?
            null : e.value;
    }
    
	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;
            //这块跟get方法一样,先找结点
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                node = p;
            else if ((e = p.next) != null) {
                if (p instanceof TreeNode)
                    node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
                else {
                    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;
    }

总结:先找结点,然后按照类型执行对应的方法,进行删除

TreeNode类

基本结构

	//继承LinkedHashMap.Entry,LinkedHashMap底层结构是 HashMap + 双向链表
    static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
        TreeNode<K,V> parent;  // red-black tree links
        TreeNode<K,V> left;
        TreeNode<K,V> right;
        TreeNode<K,V> prev;    // needed to unlink next upon deletion
        boolean red;
        TreeNode(int hash, K key, V val, Node<K,V> next) {
            super(hash, key, val, next);
        }
   }

treeifyBin方法(用链表构建红黑树)

	final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        //数组的长度小于64先扩容,而不是只要长度大于8就转化为树
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        //否则再转化
        //找到数组中的结点
        else if ((e = tab[index = (n - 1) & hash]) != null) {
        	//hd是头结点,tl是临时结点
            TreeNode<K,V> hd = null, tl = null;
            do {
            	//将Node结点替换成TreeNode结点
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                	//构建双向链表
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            if ((tab[index] = hd) != null)
            	//转化成树
                hd.treeify(tab);
        }
    }

//树的构建
        final void treeify(Node<K,V>[] tab) {
            TreeNode<K,V> root = null;
            for (TreeNode<K,V> x = this, next; x != null; x = next) {
                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;
                if (root == null) {
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                else {
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    for (TreeNode<K,V> p = root;;) {
                        int dir, ph;
                        K pk = p.key;
                        if ((ph = p.hash) > h)
                            dir = -1;
                        else if (ph < h)
                            dir = 1;
                        else if ((kc == null &&
                                  (kc = comparableClassFor(k)) == null) ||
                                 (dir = compareComparables(kc, k, pk)) == 0)
                            dir = tieBreakOrder(k, pk);

                        TreeNode<K,V> xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            root = balanceInsertion(root, x);
                            break;
                        }
                    }
                }
            }
            moveRootToFront(tab, root);
        }

总结:转化会先判断tab长度,小于64先进行扩容

split(拆分红黑树)

final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
            TreeNode<K,V> b = this;
            // Relink into lo and hi lists, preserving order
            TreeNode<K,V> loHead = null, loTail = null;
            TreeNode<K,V> hiHead = null, hiTail = null;
            int lc = 0, hc = 0;
            for (TreeNode<K,V> e = b, next; e != null; e = next) {
                next = (TreeNode<K,V>)e.next;
                e.next = null;
                if ((e.hash & bit) == 0) {
                    if ((e.prev = loTail) == null)
                        loHead = e;
                    else
                        loTail.next = e;
                    loTail = e;
                    ++lc;
                }
                else {
                    if ((e.prev = hiTail) == null)
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    ++hc;
                }
            }
            //在这之前的逻辑是将红黑树每个节点的hash和一个bit进行&运算,
            //根据运算结果将树划分为两棵红黑树,lc表示其中一棵树的节点数
            if (loHead != null) {
            	//树的结点数<=6重新构建红黑树(前提是先调用resize方法)
                if (lc <= UNTREEIFY_THRESHOLD)
                    tab[index] = loHead.untreeify(map);
                else {
                    tab[index] = loHead;
                    if (hiHead != null) // (else is already treeified)
                        loHead.treeify(tab);
                }
            }
            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    tab[index + bit] = hiHead.untreeify(map);
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }
        }

总结:resize的时候会执行红黑树的拆分,拆分成两部分,拆分后小于等于6的才会转化成链表

关于hashCode方法贴出几个常见类的

String.hashCode

    public int hashCode() {
        int h = hash;
        if (h == 0 && value.length > 0) {
            char val[] = value;

            for (int i = 0; i < value.length; i++) {
                h = 31 * h + val[i];
            }
            hash = h;
        }
        return h;
    }

Integer.hashCode

    public static int hashCode(int value) {
        return value;
    }

ArrayList.hashCode(继承AbstractList)

HashMap中的key最好不要使用可变类,比如ArrayList。
因为HashMap中的映射是基于key.hashCode(),如果key改变则key.hashCode()也会改变,导致最终映射错误

    public int hashCode() {
        int hashCode = 1;
        for (E e : this)
            hashCode = 31*hashCode + (e==null ? 0 : e.hashCode());
        return hashCode;
    }

线程安全的ConcurrentHashMap

hashmap不是线程安全的。
提到线程安全不得不提到Hashtable,Hashtable是遗留类,很多映射的常用功能与HashMap类似,不同的是它承自Dictionary类,并且是线程安全的,任一时间只有一个线程能写Hashtable,并发性不如ConcurrentHashMap,因为ConcurrentHashMap引入了分段锁。Hashtable不建议在新代码中使用,不需要线程安全的场合可以用HashMap替换,需要线程安全的场合可以用ConcurrentHashMap替换。

CAS + synchronized

在JDK1.7之前,ConcurrentHashMap是通过分段锁机制来实现的,所以其最大并发度受Segment的个数限制。因此,在JDK1.8中,ConcurrentHashMap的实现原理摒弃了这种设计,而是选择了与HashMap类似的数组+链表+红黑树的方式实现,而加锁则采用CAS和synchronized实现。

cas是什么呢,其实Java并发框架的基石一共有两块,一块是本文介绍的CAS,另一块就是AQS
这里引用一下别人的话

CAS机制是一种数据更新的方式。在具体讲什么是CAS机制之前,我们先来聊下在多线程环境下,对共享变量进行数据更新的两种模式:悲观锁模式和乐观锁模式。

悲观锁更新的方式认为:在更新数据的时候大概率会有其他线程去争夺共享资源,所以悲观锁的做法是:第一个获取资源的线程会将资源锁定起来,其他没争夺到资源的线程只能进入阻塞队列,等第一个获取资源的线程释放锁之后,这些线程才能有机会重新争夺资源。synchronized就是java中悲观锁的典型实现,synchronized使用起来非常简单方便,但是会使没争抢到资源的线程进入阻塞状态,线程在阻塞状态和Runnable状态之间切换效率较低(比较慢)。比如你的更新操作其实是非常快的,这种情况下你还用synchronized将其他线程都锁住了,线程从Blocked状态切换回Runnable华的时间可能比你的更新操作的时间还要长。

乐观锁更新方式认为:在更新数据的时候其他线程争抢这个共享变量的概率非常小,所以更新数据的时候不会对共享数据加锁。但是在正式更新数据之前会检查数据是否被其他线程改变过,如果未被其他线程改变过就将共享变量更新成最新值,如果发现共享变量已经被其他线程更新过了,就重试,直到成功为止。CAS机制就是乐观锁的典型实现。

使用

import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class ConcurrentHashMapDemo {
      private final ConcurrentHashMap<Integer,String> conHashMap = new ConcurrentHashMap<Integer,String>();
	  public static void main(String[] args) {
		  ExecutorService  service = Executors.newFixedThreadPool(3);
		  ConcurrentHashMapDemo ob = new ConcurrentHashMapDemo();
		  service.execute(ob.new WriteThreasOne());
		  service.execute(ob.new WriteThreasTwo());
		  service.execute(ob.new ReadThread());
		  service.shutdownNow();
	  }
	  class WriteThreasOne implements Runnable {
		@Override
		public void run() {
			for(int i= 1; i<=10; i++) {
				conHashMap.putIfAbsent(i, "A"+ i);
			}			
		}
	  }
	  class WriteThreasTwo implements Runnable {
		@Override
		public void run() {
			for(int i= 1; i<=5; i++) {
				conHashMap.put(i, "B"+ i);
			}
		}
	  }  
	  class ReadThread implements Runnable {
		@Override
		public void run() {
		   Iterator<Integer> ite = conHashMap.keySet().iterator();
	  	   while(ite.hasNext()){
	  		   Integer key = ite.next();
	  		   System.out.println(key+" : " + conHashMap.get(key));
		  }
		}
	  }	  
}

下篇文章接着写并发吧,太长了

参考
https://zhuanlan.zhihu.com/p/127147909
https://segmentfault.com/a/1190000015812438
https://tech.meituan.com/2016/06/24/java-hashmap.html
https://www.cnblogs.com/aaabbbcccddd/p/14849064.html
https://www.cnblogs.com/54chensongxia/p/12160085.html
https://pdai.tech/md/java/thread/java-thread-x-juc-collection-ConcurrentHashMap.html
红黑树没有基础
https://www.zhihu.com/question/312327402
https://www.jianshu.com/p/e136ec79235c

HashMap 和 ConcurrentHashMap 核心原理 HashMap 和 ConcurrentHashMap 原理、源码分析 一、HashMap原理 1.什么是HashMap: (1)HashMap 是基于Map接口的非同步实现,线程不安全,为了快速存取而设计,相对于 arrayList 查询快增删慢,LinkedList增删快查询慢的一种折中的方案。采用key-value兼职对的形式存放元素,并封装成Node对象 允许使用null为key或value,并且放在Node[0]位置。 (2)JDK1.7 及之前的版本使用数组+链表,JDK1.8之后的 阅读详情

相关推荐

ConcurrentHashMap详解

ConcurrentHashMap是如何保证线程安全的?又是如何提高并发效率的?

weixin_35794878的博客 292

ConcurrentHashMap的红黑树

红黑树是一种特殊的二叉树,主要用它存储有序的数据,提供高效的数据检索,时间复杂度为。个特性的二叉树都是红黑树,当有新的节点加入时,有可能会破坏其中一些特性,需要通。、从一个节点到该节点的子孙节点的所有路径包含相同个数的黑色节点;、如果一个节点是红色的,那么它的子节点必须是黑色的;指向红黑树中当前遍历到的节点,从根节点开始递归遍历,、当有新节点加入时,可能会破坏红黑树的特性,需要执行。,设置其颜色为黑色,最终二叉树如下:④、加入节点。的左节点是否为空,如果不为空,则把。的右节点是否为空,如果不为空,则把。

2301_76965813的博客 1031

【Isaac Sim】无头服务器远程桌面连接实战:Turbovnc配置与常见问题解决

本文详细介绍了在无头GPU服务器上通过Turbovnc远程桌面连接并运行NVIDIA Isaac Sim的实战教程。针对无图形界面服务器运行仿真软件的核心痛点,文章提供了从Turbovnc安装配置、SSH隧道建立,到以普通用户身份启动服务、解决GLXBadFBConfig等常见图形错误的完整方案,帮助开发者在云端高效部署机器人仿真环境。

weixin_29254673的博客 774

Java之ConcurrenHashMap

currenHashMap是jkd1.5引入的,其特点是:效率比Hashtable高,并发性比HashMap好。结合了两者的特点。         ConcurrentHashMap是一个线程安全的Hash Table,它的主要功能是提供了一组和HashTable功能相同但是线程安全的方法。ConcurrentHashMap可以做到读取数据不加锁,并且其内部的结构可以让其在进行写操作的时候能

anig2014的专栏 7059

别再只用GPS了!用Android手机传感器实现室内步行轨迹记录(避坑指南)

本文详细介绍了如何利用Android手机传感器(如加速度计、陀螺仪和磁力计)实现室内步行轨迹记录,克服GPS在室内的局限性。通过传感器数据采集、步态检测、航向估计和轨迹绘制等步骤,结合避坑指南和优化技巧,帮助开发者高效构建室内定位应用。

weixin_26821003的博客 274

森林冰火人html源码,森林冰火人单人版(源码)

【实例简介】java小游戏——森林冰火人,单人游戏, 实现人物行走,跳跃,吃水晶,具有计时功能,积分功能,倒计时结束游戏失败。【实例截图】【核心代码】森林冰火人单人版├── bin│ ├── game│ │ ├── Help.class│ │ ├── Logon.class│ │ ├── Main.class│ │ ├── Mykey.class│ │ ...

weixin_42507981的博客 6205

ConcurrentHashMap底层详解(图解扩容)(JDK1.8)

数据结构 使用数组+链表+红黑树来实现,利用 CAS + synchronized 来保证并发更新的安全 源码分析 put方法 public V put(K key, V value) { return putVal(key, value, false); } final V putVal(K key, V value, boolean onlyIfAbsent) { if (key == null || value == null) throw

愿万事胜意 3万+

1.全基因组重测序数据分析介绍

二代测序原理及fastq数据解读、全基因组重测序数据分析内容

weixin_53682198的博客 1886

Java并发容器学习之ConcurrentHashMap

Java学习笔记之并发容器ConcurrentHashMap以及常见面试题

qq_40623672的博客 427

PowerBI启动故障排查:环境变量与兼容性设置全指南

本文详细解析了PowerBI启动故障的常见问题,如空白界面和闪退,并提供了环境变量修改与兼容性设置的全方位解决方案。通过调整WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS环境变量和设置兼容模式,有效解决PowerBI启动问题,提升软件运行稳定性。

weixin_29255731的博客 472

微软推出突破性AI医疗诊断系统MAI-DxO:诊断准确率85.5%,是医生的4倍,成本更低

微软推出医疗AI系统MAI-DxO,通过多AI模型协作实现高效诊断,准确率达85.5%,是传统医生团队的4倍。该系统整合自然语言处理、计算机视觉等技术,模拟专家会诊流程,显著降低医疗成本60%。具备罕见病识别、基层医疗支持等功能,同时注重伦理安全和可解释性。微软计划开放部分架构,推动医疗AI普惠化。这一突破标志着医疗AI从单点工具向系统级智能的跨越,有望重塑更精准、高效的智能医疗未来。

这里汇聚了前沿的技术分享与实用的开发技巧,带你探索从创意到企业的技术创业之路。 639

HashMap 与 ConcurrentHashMap 底层实现

一、HashMap 底层源码 JDK7 版本(数组+链表) 我们存放的 hashMap 都会封装成一个节点对象 Entry(key,value),然后将此节点对象存放到一个数组中,存放前首先需要确定存放的数组下标:① 通过 hash(key) 算法得到 key 的 hashcode,并通过 hashcode的高16位和低16位进行异或操作(如果两个相应bit位相同,则结果为0,否则为1)得到32位的 int值,首先将高16位无符号右移16位与低十六位做异或运算。如果不这样做,而是直接做&运算(相

程序猿进阶 1万+

基于YOLOv10的微小目标检测,多头检测器提升小目标检测精度

引入多头检测器助力YOLOv10,暴力提升小目标检测性能

①答疑群聊服务;②YOLO大模型知识问答系统;③计算机视觉论文生成智能体; 2571

HashMap和ConcurrentHashMap源码解读

一、HashMap源码解读 1、put操作 对key的hashCode进行hash,然后再计算index; 如果没有碰撞直接放到桶bucket里 如果碰撞里了,以链表的形式存在bucket里 如果碰撞导致链表长度过长(大于等于TREEIFY_THRESHOLD),就把链表转换为红黑树 如果节点已经存在就替换old value(保证key的唯一性) 如果bucket满了(超过...

weixin_34163741的博客 177

PX4从放弃到精通(十一):混控及PWM输出

文章目录前言一、混控脚本二、使用步骤1.引入库2.读入数据总结 前言 一个人可以走的更快,一群人才能走的更远,交流学习加qq:2096723956 更多保姆级PX4+ROS学习视频:https://b23.tv/ZeUDKqy 分享知识,传递正能量,如有疏漏或不当之处,恳请指出. 一、混控脚本 混控脚本定义了不同 示例:pandas 是基于NumPy 的一种工具,该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下(示例): import numpy as np import pand

超维空间科技的博客 1万+

OV9734 DATASHEET,完整规格书

OV9734完整规格书,包括电气参数,尺寸规格,寄存器配置表等

全面解读ConcurrentHashMap:Java中的高效并发数据结构

ConcurrentHashMap是Java集合框架中的一员,它提供了一种线程安全的哈希表实现。与普通的HashMap相比,ConcurrentHashMap在多线程环境下能够更高效地处理并发访问,保证了线程安全性和性能。ConcurrentHashMap是Java中高效的线程安全哈希表实现,适用于需要高并发读写的场景。它通过分段锁机制实现了更好的性能和并发控制,可以作为HashMap的线程安全替代品,在多线程环境中广泛应用于缓存、并发计算等场景。

微笑听雨 7958

IEM模型,地表粗糙度模拟

利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟

从HashMap到ConcurrentHashMap,面试官究竟在考什么?

HashMap 和 ConcurrentHashMap 就像是 Java 集合家族中的两位得力干将,各自在不同的领域发光发热。HashMap 以其在单线程环境下的简单高效,成为日常开发中处理键值对数据的首选工具;而 ConcurrentHashMap 则凭借出色的线程安全机制和高并发性能,在多线程的复杂场景中独领风骚。​希望通过本文的剖析,能帮助大家在面试中对这两个集合类的问题应对自如。同时,集合框架博大精深,HashMap 和 ConcurrentHashMap 只是其中的冰山一角。

m0_71836706的博客 1016

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

ConcurrentHashMap 源码解读

全网最详细最全面的 ConcurrentHashMap 源码解读。和大家一起深入浅出的学习 JDK8 中的源码

CodeSuc 的技术博客 934

HashMap与ConcurrentHashMap的底层原理

1.HashMap结构 HashMap基于数组,通过散列函数在O(1)时间内来访问记录。首先HashMap里面实现一个静态内部类Entry,Map里面的内容都保存在Entry[]里面。然后,通过对key的hashcode & 数组长度得到在数组中位置,如有冲突,则在冲突位置形成链表,即拉链法。 2.HashMap字段属性 2.1数组table和初始容量 //初始化使用,长度总是 ...

学习猴 653

HashMap和ConcurrentHashMap源码分析

目录 HashMap 1 HashMap概述 2 涉及到的数据结构:处理hash冲突的链表和红黑树以及位桶 3 HashMap源码分析 类的继承关系 类的属性 构造函数 hash算法 重要方法分析 ConcurrentHashMap 重要的属性 put方法 Remove方法 size方法 HashMap 1 HashMap概述 在JDK1.8之前,HashM...

WM_CARA的博客 1168

《HashMap 与 ConcurrentHashMap 深度对比:从原理到实战选择》

Java中的HashMap和ConcurrentHashMap核心差异在于线程安全性和应用场景。HashMap为单线程设计,无锁机制,性能高但不安全;ConcurrentHashMap专为多线程设计,采用CAS+synchronized细粒度锁,保证安全的同时提升并发性能。关键区别:HashMap允许null值,迭代器是Fail-Fast;ConcurrentHashMap禁止null值,迭代器是Fail-Safe并支持原子操作。选型标准:单线程用HashMap,多线程必须用ConcurrentHashMa

yh云想的博客 1476

【应届面试篇】谈一谈HashMap 及 ConcurrentHashMap?- 附源码解读

以面试参考答案为主文章,尽可能保持简洁,本文为了方便理解附上部分源码方便理解。

krystal996的博客 258

HashMap、ConcurrentHashMap源码解读(JDK7/8)

HashMap集合(高级) 1.HashMap集合简介 ​ HashMap基于哈希表的Map接口实现,是以key-value存储形式存在,即主要用来存放键值对。HashMap 的实现不是同步的,这意味着它不是线程安全的。它的key、value都可以为null。此外,HashMap中的映射不是有序的。 ​ JDK1.8 之前 HashMap 由 数组+链表 组成的,数组是 HashMap 的主体,链...

努力充实,远方可期 1814

HashMap源码解读—Java8版本

做任何事情都要用心,要非常关注细节。看起来不起眼的、繁琐的工作做透了会有意想不到的价值。当然要想成为一个技术大牛也需要一定的思想格局,思想决定未来你要往哪个方向去走, 建议多看一些人生规划方面的书籍,多学习名人的思想格局,未来你的路会走的更远。更多的技术点思维导图我已经做了一个整理,涵盖了当下互联网最流行99%的技术点,在这里我将这份导图分享出来,以及为金九银十准备的一整套面试体系,上到集合,下到分布式微服务《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》

2401_84408734的博客 810

深入源码:解读 HashMap 的线程陷阱与 ConcurrentHashMap 的并发艺术

从HashMap的“死链”、“数据覆盖”陷阱,到ConcurrentHashMap从“分段锁”到“CAS+synchronized”的精妙设计,我们看到了Java并发开发者们在追求性能与安全平衡点上的不懈努力。ConcurrentHashMap通过降低锁的粒度来提升并发性能,其设计经历了从“分段锁”到“CAS + synchronized”的现代化演进。(一种分片计数机制),并发更新时不同线程操作不同的Cell,最后求和,避免了激烈的CAS竞争,是。结合CAS无锁算法,实现了更低的开销和更高的性能。

2301_78447438的博客 757

ConcurrentHashMap解读

文章目录前言JDK1.7大致了解源码分析归纳总结JDK1.8大致了解源码分析归纳总结 前言 HashMap: 在多线程情况下,put操作的时候,插入的元素超过了容量(由负载因子决定)的范围就会触发扩容操作,这个会重新将原数组移动到到新的扩容数组中,在多线程的环境下,存在同时其他的元素也在进行put操作,如果hash值相同,可能出现同时在同一数组下用链表表示,造成闭环,导致在get时会出现死循环,这也造成了HashMap线程不安全。 JDK1.7 大致了解 源码分析 归纳总结 JDK1.8 大致了解 源码

weixin_44861399的博客 694
上一篇: springIOC原理相关原理
下一篇: jvm双亲委派源码,自己看,自己写ClassLoader
小健健健
博客等级 码龄8年 101粉丝 68原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值