JDK1.8 中的hashmap和concurrentHashMap

最新推荐文章于 2022-12-31 13:13:11 发布
最新推荐文章于 2022-12-31 13:13:11 发布
阅读量3.1k 收藏 5
点赞数 7
分类专栏： Java 文章标签： hashmap
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weiyongxuan/article/details/48344393
版权

hashmap

在JDK1.6中，HashMap采用Node数组+链表实现，即使用链表处理冲突，同一hash值的链表都存储在一个链表里。但是当位于一个桶中的元素较多，即hash值相等的元素较多时，通过key值依次查找的效率较低。而JDK1.8中，HashMap采用Node数组+链表+红黑树实现，当链表长度超过阈值（8）时，将链表转换为红黑树，这样大大减少了查找时间。

hashMap的实现

put方法的实现

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

hash函数

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

//其中的hashCode()是一个native方法

红黑树

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);
        }

        /**
         * Returns root of tree containing this node.
         */
        final TreeNode<K,V> root() {
            for (TreeNode<K,V> r = this, p;;) {
                if ((p = r.parent) == null)
                    return r;
                r = p;
            }
        }

Node存储对象，该类实现了Map.Entry接口

其实就是一个链表

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;

        Node(int hash, K key, V value, Node<K,V> next) {
            this.hash = hash;
            this.key = key;
            this.value = value;
            this.next = next;
        }

        public final K getKey()        { return key; }
        public final V getValue()      { return value; }
        public final String toString() { return key + "=" + value; }

        public final int hashCode() {
            return Objects.hashCode(key) ^ Objects.hashCode(value);
        }

        public final V setValue(V newValue) {
            V oldValue = value;
            value = newValue;
            return oldValue;
        }

        public final boolean equals(Object o) {
            if (o == this)
                return true;
            if (o instanceof Map.Entry) {
                Map.Entry<?,?> e = (Map.Entry<?,?>)o;
                if (Objects.equals(key, e.getKey()) &&
                    Objects.equals(value, e.getValue()))
                    return true;
            }
            return false;
        }
    }

存储过程

首先，当添加一个元素（key-value）时，就首先计算元素key的hash值，以此确定插入数组中的位置，但是可能存在同一hash值的元素已经被放在数组同一位置了，这时就添加到同一hash值的元素的后面，他们在数组的同一位置，但是形成了链表
而当链表长度太长时，链表就转换为红黑树，这样大大提高了查找的效率。

putVal的方法的实现

transient Node<K,V>[] table;//存储的数组

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //1. 判断键值对数组tab[]是否为空或为null，否则resize()；
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //2. 根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加(n - 1) & 
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        //3. 判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理  
        else {
            Node<K,V> e; K k;
            //第一节节点hash值同，且key值与插入key相同
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else if (p instanceof TreeNode)//属于红黑树处理冲突
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
            //链表处理冲突
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        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;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

putVal的步骤：

  1. 判断键值对数组tab[]是否为空或为null，否则resize()；
  2. 根据键值key计算hash值得到插入的数组索引i，如果tab[i]==null，直接新建节点添加
  3. 判断当前数组中处理hash冲突的方式为链表还是红黑树(check第一个节点类型即可),分别处理

获取过程

注意HashMap中key和value都容许为null

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;
        //hash & (length-1)得到对象的地址
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
            if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
                return first;

            if ((e = first.next) != null) {
 //如果第一个节点是TreeNode,说明采用的是数组+红黑树结构处理冲突，遍历红黑树，得到节点值
                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;
    }

concurrentHashMap

数据结构

核心存储结构是segment

static class Segment<K,V> extends ReentrantLock implements Serializable {
        private static final long serialVersionUID = 2249069246763182397L;
        final float loadFactor;
        Segment(float lf) { this.loadFactor = lf; }
    }

为什么在高并发的情况下高效？

一个ConcurrentHashMap由多个segment组成，每一个segment都包含了一个HashEntry数组的 hashtable， 每一个segment包含了对自己的hashtable的操作，比如get，put，replace等操作，这些操作发生的时候，对自己的 hashtable进行锁定。由于每一个segment写操作只锁定自己的hashtable，所以可能存在多个线程同时写的情况，性能无疑好于只有一个 hashtable锁定的情况。

在ConcurrentHashMap的remove，put操作还是比较简单的，都是将remove或者put操作交给key所对应的segment去做的，所以当几个操作不在同一个segment的时候就可以并发的进行。

remove

public V remove(Object key) {
    return replaceNode(key, null, null);
}

//注意，这里不是加锁，是同步实现的
**synchronized (f)**
final V replaceNode(Object key, V value, Object cv) {
        int hash = spread(key.hashCode());
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0 ||
                (f = tabAt(tab, i = (n - 1) & hash)) == null)
                break;
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                boolean validated = false;
                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;
                            }
                        }
                        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));
                                }
                            }
                        }
                    }
                }
                if (validated) {
                    if (oldVal != null) {
                        if (value == null)
                            addCount(-1L, -1);
                        return oldVal;
                    }
                    break;
                }
            }
        }
        return null;
    }

put

这里也是同步

    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) {
        if (key == null || value == null) throw new NullPointerException();
        int hash = spread(key.hashCode());
        int binCount = 0;
        for (Node<K,V>[] tab = table;;) {
            Node<K,V> f; int n, i, fh;
            if (tab == null || (n = tab.length) == 0)
                tab = initTable();
            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
            }
            else if ((fh = f.hash) == MOVED)
                tab = helpTransfer(tab, f);
            else {
                V oldVal = null;
                synchronized (f) {
                    if (tabAt(tab, i) == f) {
                        if (fh >= 0) {
                            binCount = 1;
                            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;
                                }
                            }
                        }
                        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) {
                    if (binCount >= TREEIFY_THRESHOLD)
                        treeifyBin(tab, i);
                    if (oldVal != null)
                        return oldVal;
                    break;
                }
            }
        }
        addCount(1L, binCount);
        return null;
    }

get

不加锁，也没有同步

 public V get(Object key) {
        Node<K,V>[] tab; Node<K,V> e, p; int n, eh; K ek;
        int h = spread(key.hashCode());
        if ((tab = table) != null && (n = tab.length) > 0 &&
            (e = tabAt(tab, (n - 1) & h)) != null) {
            if ((eh = e.hash) == h) {
                if ((ek = e.key) == key || (ek != null && key.equals(ek)))
                    return e.val;
            }
            else if (eh < 0)
                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;
            }
        }
        return null;
    }
韦轩
关注
  • 7
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
【java】并发容器之ConcurrentHashMap(JDK 1.8版本)
九师兄
06-03 2536
在使用HashMap时在多线程情况下扩容会出现CPU接近100%的情况，因为hashmap并不是线程安全的，通常我们可以使用在java体系中古老的hashtable类，该类基本上所有的方法都采用synchronized进行线程安全的控制，可想而知，在高并发的情况下，每次只有一个线程能够获取对象监视器锁，这样的并发性能的确不令人满意。另外一种方式通过Collections的将hashmap包装成一个线程安全的map。
在linux上部署Java项目
我自倾怀，君且随意
08-12 3882
在linux上部署Java项目查看tomcat的运行状态ps -auxwf | grep java或者查看 端口的占用,具体端口看自己的配置netstat -lnpt | grep 8080启动和关闭 打开 ./startup.sh 关闭 ./shutdown.sh查看MySql的运行状态/etc/init.d/mysqld status #已添加到系统服务，以下命令可以查看 service my
ConcurrentHashMap的实现原理(JDK1.7和JDK1.8).pdf
11-26
哈希表就是一种以 键-值(key-indexed) 存储数据的结构，我们只要输入待查 找的值即 key，即可查找到其对应的值。 哈希的思路很简单，如果所有的键都是整数，那么就可以使用一个简单的无序数 组来实现：将键作为索引，值即为其对应的值，这样就可以快速访问任意键的值。 这是对于简单的键的情况，我们将其扩展到可以处理更加复杂的类型的键。
对ConcurrentHashMap的remove操作解析
qwe3642的博客
10-09 1万+
  ConcurrentHashMap的remove源码： /** * Removes the key (and its corresponding value) from this map. * This method does nothing if the key is not in the map. * * @param key the key ...
ConcurrentHashMap详解 jdk1.8源码分析
小哥骑单车
07-21 3984
上一篇： HashMap源码详解分析，基于jdk1.8 ConcurrentHashMap jdk1.7简介和 jdk1.8源码分析 目录 一、ConcurrentHashMap，jdk1.7简介 1、ConcurrentHashMap产生背景 2、ConcurrentHashMap 1.7版本采用分段锁的简介： 3、put存元素操作时候 4、JDK1.7版本的Con...
JDK1.8ConcurrentHashMap源码解析第二部分（添加元素、删除元素、扩容、查找元素）
weixin_43478710的博客
11-13 1062
ConcurrentHashMap源码解析第二部分，着重分析ConcurrentHashMap添加元素、删除元素、扩容、查找元素的具体流程 1、添加元素 添加元素用到的是putVal方法 public V put(K key, V value) { return putVal(key, value, false); } //onlyIfAbsent为true时找到相同节点不替换 为false就替换 final V putVal(K key, V value, boolean onlyIfA
Java容器（二）-CurrentHashMap详解（JDK1.8）
热门推荐
码小二的博客
05-27 4万+
摘要 在涉及到Java多线程同步时，如果我们使用HashMap可能会导致死锁问题吗，但是使用HashTable效率又不高。所以这个时候ConcurrentHashmap是我们最好的选择。 为什么使用ConcurrentHashMap： 在多线程环境中使用HashMap的put方法有可能导致程序死循环，因为多线程可能会导致HashMap形成环形链表，即链表的一个节点的next节点永不为nul...
HashMap (jdk1.8) remove（Object key)方法详细注释
汉堡配大蒜
07-13 445
remove（Object key)功能：删除指定的key对应的元素。 /* * 删除节点 * Object key：需要删除的key * */ public V remove(Object key) { HashMap.Node<K,V> e; //定义Node类型的节点e /* * 调用removeNode(hash(key), key, null, false, true)，把执行结果赋值给e,如果e为
【Java中JDK1.8版本并发集合ConcurrentHashMap】
Coder_ljw的博客
12-31 1254
【Java中JDK1.8版本并发集合ConcurrentHashMap】ConcurrentHashMap是线程安全的HashMap ConcurrentHashMap在JDK1.8中是以CAS+synchronized实现的线程安全 CAS：在没有hash冲突时（Node要放在数组上时） synchronized：在出现hash冲突时（Node存放的位置已经有数据了） 存储的结构：数组+链表+红黑树
JDK 1.8 HashMap解析
非学无以广才，非志无以成学
07-11 2510
Map在Java里边是一个接口，常见的实现类有HashMap、LinkedHashMap、TreeMap、hashTable和ConcurrentHashMap在Java中，哈希表的结构是数组+链表的方式 HashMap底层数据结构是数组+链表/红黑树 LinkedHashMap底层数据结构是数组+链表/红黑树+双向链表 TreeMap底层数据结构是红黑树 HashTable底层数据结构是数组+链表 而ConcurrentHashMap底层数据结构也是数组+链表/红黑树思考：源码基本属性： table 数组
JDK1.8中的ConcurrentHashMap
老王不掉头发的博客
03-02 3224
一、jdk1.8容器初始化 1、源码分析 在jdk8的ConcurrentHashMap中一共有5个构造方法，这四个构造方法中都没有对内部的数组做初始化， 只是对一些变量的初始值做了处理 jdk8的ConcurrentHashMap的数组初始化是在第一次添加元素时完成 //没有维护任何变量的操作，如果调用该方法，数组长度默认是16 public ConcurrentHashMap() { } //传递进来一个初始容量，ConcurrentHashMap会基于这个值计算一个比这个值
jdk1.8-source:JDK1.8源码分析包
03-23
JDK1.8源码分析 相关的原始码分析结果会以注解的形式体现到原始码中 已完成部分： ReentrantLock CountDownLatch Semaphore HashMap TreeMap LinkedHashMap ConcurrentHashMap 执行器 ...
jdk1.8_64.7z
11-03
jdk1.8 中对集合的底层结构做了调整。 如HashMap从1.7的数据+链表的形式调整为数据+链表+红黑树。 ConcurrentHashMap从分段机制+数组+链表+红黑树到CAS+数组+链表+红黑树。 这里先简要记录，后续会详解Map的原理与...
一文让你彻底理解JavaHashMap和ConcurrentHashMap
02-24
众所周知HashMap底层是基于数组+链表组成的，不过在jdk1.7和1.8中具体实现稍有不同。1.7中的数据结构图：先来看看1.7中的实现。这是HashMap中比较核心的几个成员变量；看看分别是什么意思？初始化桶大小，因为底层是...
Maven使用私服setting.xml中的配置
我自倾怀，君且随意
08-07 9605
Maven使用私服setting.xml中的配置setting.xml中的配置使用maven,每次都是从中央仓库下载依赖包，网络很渣，只有使用Nexus搭建个私服。下面是setting.xml中的配置文件 <?xml version="1.0" encoding="UTF-8"?><settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
java jdbc 与mysql连接的基本步骤
我自倾怀，君且随意
07-25 4057
Java与mysql链接的基本步骤： 第一步：
通过配置文件实现通用的jdbc链接
我自倾怀，君且随意
08-03 2800
一般在项目当中，我们要多次与数据库jin'xing'jia
数据库的增删改查操作
我自倾怀，君且随意
07-28 2320
与之前的工具类放在同一个包下。
jdk1.8中ConcurrentHashMap的数据结构
最新发布
10-19
JDK1.8版本的ConcurrentHashMap的数据结构基本上和HashMap一样，不过保证线程安全性。相对于JDK1.7版本的ReentrantLock+Segment+HashEntry，JDK1.8版本的ConcurrentHashMap只是增加了同步的操作来控制并发，使用了synchronized+CAS+HashEntry+红黑树的数据结构。其中，HashEntry是一个链表节点，用于存储键值对，红黑树则是用于优化查找效率的。这种数据结构的设计可以大大提高ConcurrentHashMap的并发能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值