HashMap和ConcurrentHashMap

最新推荐文章于 2024-09-06 16:12:45 发布
最新推荐文章于 2024-09-06 16:12:45 发布
阅读量283 收藏
点赞数
分类专栏： java 文章标签： java HashMap ConcurrentHashMap

 http://blog.csdn.net/zldeng19840111/article/details/6703104

HashMap

 

hashmap本质数据加链表。根据key取得hash值，然后计算出数组下标，如果多个key对应到同一个下标，就用链表串起来，新插入的在前面。

看3段重要代码摘要：


a：

[java]  view plain  copy
  1. public HashMap(int initialCapacity, float loadFactor) {  
  2.     int capacity = 1;  
  3.     while (capacity < initialCapacity)  
  4.         capacity <<= 1;  
  5.   
  6.     this.loadFactor = loadFactor;  
  7.     threshold = (int)(capacity * loadFactor);  
  8.     table = new Entry[capacity];  
  9.     init();  
  10. }  

 有3个关键参数：
capacity：容量，就是数组大小
loadFactor：比例，用于扩容
threshold:=capacity*loadFactor   最多容纳的Entry数，如果当前元素个数多于这个就要扩容（capacity扩大为原来的2倍）

b:

[java]  view plain  copy
  1. public V get(Object key) {  
  2.     if (key == null)  
  3.         return getForNullKey();  
  4.     int hash = hash(key.hashCode());  
  5.     for (Entry<K,V> e = table[indexFor(hash, table.length)];  
  6.          e != null;  
  7.          e = e.next) {  
  8.         Object k;  
  9.         if (e.hash == hash && ((k = e.key) == key || key.equals(k)))  
  10.             return e.value;  
  11.     }  
  12.     return null;  
  13. }  


 根据key算hash值，再根据hash值取得数组下标，通过数组下标取出链表，遍历链表用equals取出对应key的value。


c:   

[java]  view plain  copy
  1. public V put(K key, V value) {  
  2.         if (key == null)  
  3.             return putForNullKey(value);  
  4.         int hash = hash(key.hashCode());  
  5.         int i = indexFor(hash, table.length);  
  6.         for (Entry<K,V> e = table[i]; e != null; e = e.next) {  
  7.             Object k;  
  8.             if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {  
  9.                 V oldValue = e.value;  
  10.                 e.value = value;  
  11.                 e.recordAccess(this);  
  12.                 return oldValue;  
  13.             }  
  14.         }  
  15.   
  16.         modCount++;  
  17.         addEntry(hash, key, value, i);  
  18.         return null;  
  19.     }  

从数组（通过hash值）取得链表头，然后通过equals比较key，如果相同，就覆盖老的值，并返回老的值。（该key在hashmap中已存在）

否则新增一个entry，返回null。新增的元素为链表头，以前相同数组位置的挂在后面。

另外：modCount是为了避免读取一批数据时，在循环读取的过程中发生了修改，就抛异常

  if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
         

下面看添加一个map元素

[html]  view plain  copy
  1. void addEntry(int hash, K key, V value, int bucketIndex) {  
  2.     Entry<K,V> e = table[bucketIndex];  
  3.     table[bucketIndex] = new Entry<K,V>(hash, key, value, e);  
  4.     if (size++ >= threshold)  
  5.         resize(2 * table.length);  
  6. }  

新增后，如果发现size大于threshold了，就resize到原来的2倍

[java]  view plain  copy
  1. void resize(int newCapacity) {  
  2.   
  3.     Entry[] newTable = new Entry[newCapacity];  
  4.     transfer(newTable);  
  5.     table = newTable;  
  6.     threshold = (int)(newCapacity * loadFactor);  
  7. }  



新建一个数组，并将原来数据转移过去
 

[java]  view plain  copy
  1. void transfer(Entry[] newTable) {  
  2.         Entry[] src = table;  
  3.         int newCapacity = newTable.length;  
  4.         for (int j = 0; j < src.length; j++) {  
  5.             Entry<K,V> e = src[j];  
  6.             if (e != null) {  
  7.                 src[j] = null;  
  8.                 do {  
  9.                     Entry<K,V> next = e.next;  
  10.                     int i = indexFor(e.hash, newCapacity);  
  11.                     e.next = newTable[i];  
  12.                     newTable[i] = e;  
  13.                     e = next;  
  14.                 } while (e != null);  
  15.             }  
  16.         }  
  17.     }  


将原来数组中的链表一个个取出，然后遍历链表中每个元素，重新计算index并放入新数组。每个处理的也放链表头。

在取出原来数组链表后，将原来数组置空（为了大数据量复制时更快的被垃圾回收？）

还有两点注意：

static class Entry<K,V> implements Map.Entry<K,V>是hashmap的静态内部类，iterator之类的是内部类，因为不是每个元素都需要持有map的this指针。

HashMap把  transient Entry[] table;等变量置为transient，然后override了readObject和writeObject，自己实现序列化。



ConcurrentHashMap：

在hashMap的基础上，ConcurrentHashMap将数据分为多个segment，默认16个（concurrency level），然后每次操作对一个segment加锁，避免多线程锁得几率，提高并发效率。

[java]  view plain  copy
  1. public V get(Object key) {  
  2.       int hash = hash(key.hashCode());  
  3.       return segmentFor(hash).get(key, hash);  
  4.   }  
  5.   
  6.  final Segment<K,V> segmentFor(int hash) {  
  7.       return segments[(hash >>> segmentShift) & segmentMask];  
  8.   }  


 

in class Segment：

[java]  view plain  copy
  1. V get(Object key, int hash) {  
  2.          if (count != 0) { // read-volatile  
  3.              HashEntry<K,V> e = getFirst(hash);  
  4.              while (e != null) {  
  5.                  if (e.hash == hash && key.equals(e.key)) {  
  6.                      V v = e.value;  
  7.                      if (v != null)  
  8.                          return v;  
  9.                      return readValueUnderLock(e); // recheck  
  10.                  }  
  11.                  e = e.next;  
  12.              }  
  13.          }  
  14.          return null;  
  15.      }  
[java]  view plain  copy
  1.         /** 
  2.          * Reads value field of an entry under lock. Called if value 
  3.          * field ever appears to be null. This is possible only if a 
  4.          * compiler happens to reorder a HashEntry initialization with 
  5.          * its table assignment, which is legal under memory model 
  6.          * but is not known to ever occur. 
  7.          */     
  8.         V readValueUnderLock(HashEntry<K,V> e) {  
  9.             lock();  
  10.             try {  
  11.                 return e.value;  
  12.             } finally {  
  13.                 unlock();  
  14.             }  
  15.         }  


 

注意，这里在并发读取时，除了key对应的value为null之外，并没有使用锁，如何做到没有问题的呢，有以下3点：
1.       HashEntry<K,V> getFirst(int hash) {
            HashEntry<K,V>[] tab = table;
            return tab[hash & (tab.length - 1)];
        }
这里如果在读取时数组大小（tab.length）发生变化，是会导致数据不对的，但transient volatile HashEntry<K,V>[] table;是volatile得，数组大小变化能立刻知道

2.    static final class HashEntry<K,V> {
        final K key;
        final int hash;
        volatile V value;
        final HashEntry<K,V> next;
这里next是final的，就保证了一旦HashEntry取出来，整个链表就是正确的。

3.value是volatile的，保证了如果有put覆盖，是可以立刻看到的。

 

 

[html]  view plain  copy
  1. public V put(K key, V value) {  
  2.         if (value == null)  
  3.             throw new NullPointerException();  
  4.         int hash = hash(key.hashCode());  
  5.         return segmentFor(hash).put(key, hash, value, false);  
  6.     }  
  7.   
  8.  V put(K key, int hash, V value, boolean onlyIfAbsent) {  
  9.             lock();  
  10.             try {  
  11.                 int c = count;  
  12.                 if (c++ > threshold) // ensure capacity  
  13.                     rehash();  
  14.                 HashEntry<K,V>[] tab = table;  
  15.                 int index = hash & (tab.length - 1);  
  16.                 HashEntry<K,V> first = tab[index];  
  17.                 HashEntry<K,V> e = first;  
  18.                 while (e != null && (e.hash != hash || !key.equals(e.key)))  
  19.                     e = e.next;  
  20.   
  21.                 V oldValue;  
  22.                 if (e != null) {  
  23.                     oldValue = e.value;  
  24.                     if (!onlyIfAbsent)  
  25.                         e.value = value;  
  26.                 }  
  27.                 else {  
  28.                     oldValue = null;  
  29.                     ++modCount;  
  30.                     tab[index] = new HashEntry<K,V>(key, hash, first, value);  
  31.                     count = c; // write-volatile  
  32.                 }  
  33.                 return oldValue;  
  34.             } finally {  
  35.                 unlock();  
  36.             }  
  37.         }  


  这里除了加锁操作，其他和普通HashMap原理上无太大区别。

 

 

还有一点不理解的地方：

对于get和put/remove并发发生的时候，如果get的HashEntry<K,V> e = getFirst(hash);链表已经取出来了，这个时候put放入一个entry到链表头，如果正好是需要取的key，是否还是会取不出来？

remove时，会先去除需要remove的key，然后把remove的key前面的元素一个个接到链表头，同样也存在remove后，以前的head到了中间，也会漏掉读取的元素。

[java]  view plain  copy
  1. ++modCount;  
  2.                      HashEntry<K,V> newFirst = e.next;  
  3.                      for (HashEntry<K,V> p = first; p != e; p = p.next)  
  4.                          newFirst = new HashEntry<K,V>(p.key, p.hash,  
  5.                                                        newFirst, p.value);  
  6.                      tab[index] = newFirst;  
  7.                      count = c; // write-volatile  


 

青峰祭坛
关注
专栏目录
HashMap和ConcurrentHashMap区别
Mr.xing的博客
03-26 1056
HashMap、ConcurrentHashMap
HashMap和ConcurrentHashMap区别看完没人能难住你
weixin_44741610的博客
09-05 6327
关于HashMap与ConcurrentHashMap的的区别，在面试的时候基本都会被问到，所以下面我们就来谈谈相关知识点： 一、HashMap概述 本质浅谈 HashMap是基于哈希表的Map接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap类与Hashtable大致相同。）Hashmap本质是数组加链表。根据key取得hash值，然后计算出数组下标，如果多个key对应到同一个下
HashMap和ConcurrentHashMap浅析
热门推荐
08-19 5万+
HashMap   hashmap本质数据加链表。根据key取得hash值，然后计算出数组下标，如果多个key对应到同一个下标，就用链表串起来，新插入的在前面。 看3段重要代码摘要： a： public HashMap(int initialCapacity
HashMap及ConcurrentHashMap
微微 -------
04-05 2678
hashmap 及 concurrenthashmap 底层实现原理
HashMap与ConcurrentHashMap
小猪奋斗
06-17 155
HashMap 众所周知 HashMap 底层是基于 数组 + 链表 组成的，不过在 jdk1.7 和 1.8 中具体实现稍有不同。为什么会使用数组+链表，而不是只使用数组。因为有可能存在hashCode相同的情况，因此就需要+数组加链表。 在jdk1.7版本 HashMap的数据结构 部分源码如下： HashMap 中比较核心的几个成员变量说明： 1、初始化桶大小，因为底层是数组，所以这个默...
HashMap 与 ConcurrentHashMap
最新发布
longlongqin的博客
09-06 881
size：是HashMap中实际存在的键值对数量。注意，size与 table数组的长度length是不一样的。（也叫 哈希数组、哈希槽位 数组、散列表）。Node类作为HashMap中的一个内部类，每个 Node 包含了一个 key-value 键值对。其中的next属性就是在哈希冲突之后，使用链地址法解决哈希冲突。如下图所示，散列表（table桶数组）中的每个元素就是一个Node。散列表（table桶数组）的长度length（Capacity）默认值是16。
详谈HashMap和ConcurrentHashMap的区别(HashMap的底层源码)
08-29
HashMap和ConcurrentHashMap的区别 HashMap和ConcurrentHashMap是Java语言中两个常用的哈希表实现，它们都继承自AbstractMap类，实现了Map接口，但是它们之间存在着一些关键的区别。 首先，从数据结构上讲，...
HashMap和ConcurrentHashMap的扩容过程详解
felix
06-04 1854
1. HashMap的扩容过程 首先判断扩容，插入数据后，如果容量大于threshold（容量*负载因子），则进行扩容； 获取当前容量，若当前容量大于0，并且大于MAXIMUM_CAPACITY = 1 << 30，则不进行扩容，将 threshold = Integer.MAX_VALUE进行赋值。 否则创建新的数组，将容量进行两倍扩大，threshold也进行两倍扩容,下面截取部分源码； if (oldCap > 0) { if (oldCap
java7-8中的 HashMap和ConcurrentHashMap全解析.pdf
10-22
在Java 7和8中，HashMap和ConcurrentHashMap是两种重要的数据结构，分别用于非线程安全和线程安全的键值对存储。本篇文章将深入解析这两种数据结构的内部实现，帮助读者理解它们的工作原理。 HashMap是Java中最常用...
一文让你彻底理解JavaHashMap和ConcurrentHashMap
02-24
Map这样的KeyValue在软件开发中是非常经典的结构，常用于在内存中存放数据。本篇主要想讨论ConcurrentHashMap这样一个并发容器，在正式开始之前我觉得有必要谈谈HashMap，没有它就不会有后面的ConcurrentHashMap。众所周知HashMap底层是基于数组+链表组成的，不过在jdk1.7和1.8中具体实现稍有不同。1.7中的数据结构图：先来看看1.7中的实现。这是HashMap中比较核心的几个成员变量；看看分别是什么意思？初始化桶大小，因为底层是数组，所以这是数组默认的大小。桶最大值。默认的负载因子（0.75）table真正存放数据的数组。Map存放数量的大小。桶
ConcurrentMap和HashMap的区别
zlmind技术博客
03-02 369
类 HASHSET&lt;E&gt; 所有已实现的接口：Serializable, Cloneable, Iterable&lt;E&gt;, Collection&lt;E&gt;, Set&lt;E&gt; 此类实现 Set 接口，由哈希表（实际上是一个 HashMap 实例）支持。它不保证 set 的迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用 null 元素。 ...
HashMap和ConcurrentHashMap的区别
qq_36896711的博客
11-22 561
在segment中的put方法，加锁lock()，再次hash确定存放的hashEntry数组中的位置，在链表中根据hash值和equals方法进行比较，如果相同就直接覆盖，如果不同就插入到链表中，最后把锁给释放。如果把上面的执行用一句话来归纳的话，就相当于是ConcurrentHashMap通过对头结点加锁来保证线程安全，这样设计的好处是使得锁的粒度相比segment来说更小了，发生hash冲突和加锁的频率也更低了，而在并发场景下的操作性能也提高了，数据量大的时候，查询性能也得到了进一步的提升。
HashMap和ConcurrentHashMap的区别，详解HashMap和ConcurrentHashMap数据结构
qq_39350797的博客
04-08 3627
在讨论哈希表之前，我们先大概了解下其他数据结构在新增，查找等基础操作执行性能数组采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)线性链表。
详解HashMap&ConcurrentHashMap
小小周的博客
03-06 1954
HashMap 从以下5点入手 数据结构： 1.7 数组+链表 1.8 数组+链表+红黑树 当链表长度大于8时会转换为红黑树，当红黑树节点小于6时会转换成链表。 因为红黑树是自平衡二叉查找树，检索效率为O(logn) 引入红黑树是为了解决哈希碰撞后链表索引效率的问题，以加快检索速度。 hashmap结构源码： static class Node<K,V> implements Map.Entry<K,V> { final int hash;
HashMap和ConcurrentHashMap的区别，HashMap的底层源码
anrm74451的博客
08-10 117
HashMap本质是数组加链表，根据key取得hash值，然后计算出数组下标，如果多个key对应到同一个下标，就用链表串起来，新插入的在前面。 ConcurrentHashMap在HashMap的基础上将数据分为多个segment，默认16个，然后每次操作对一个segment加锁，避免多线程锁的几率，提高并发效率。 1. HashMap的数据结构 HashMap底层就是一个数组结构...
Hashmap和ConcurrentHashmap的区别
Mr.zhang的博客
09-23 1万+
HashTable （1）底层数组+链表实现，无论key还是value都不能为null，线程安全，实现线程安全的方式是在修改数据时锁住整个HashTable，效率低，ConcurrentHashMap做了相关优化 （2）初始size为11，扩容：newsize = olesize*2+1 （3）计算index的方法：index = (hash & 0x7FFFFFFF) % tab.length HashMap （1）底层数组+链表实现，可以存储null键和null值，线程不安全 （2）初始size
HashMap与ConcurrentHashMap,HashTable的区别，以及底层实现
qq_43234517的博客
08-17 596
一.HashMap的resize(rehash)： 当hashMap中的元素越来越多的时候，hash冲突的几率也越来越高，因为数组的长度是固定的。所以为了提高查询的效率，就要对HashMap的数组进行扩容，数组扩容这个操作也会出现在ArrayList中，这是一个常用的操作，而在HashMap数组扩容之后，最消耗性能的点就出现了：原数组中的数据必须重新计算其在新数组中的位置，并放进去，这就是resize。当HashMap中的元素个数超过数组大小loadFactor时，就会进行数组扩容，loadFactor的
HashMap和ConcurrentHashMap源码讲解
zjs40的博客
01-30 1081
HashMap和ConcurrentHashMap源码讲解 github地址 HashMap put : 1.判断 table 是否空，空则初始化 2.计算槽位 3.槽位首节点如果为空直接插入槽 4.槽位首节点不为空 4.1 判断槽位首节点的 key 相同 替换 value 4.2 槽位首节点的 key 相同 4.2.1 节点是
hashmap和ConcurrentHashMap
03-24
HashMap和ConcurrentHashMap都是Java中的集合类，用于存储键值对。 HashMap是非线程安全的，适用于单线程环境。它基于哈希表实现，通过将键映射到存储桶来存储和获取值。当多个键映射到同一个存储桶时，它们会以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值