Java HashMap详解:一场由于不懂Map集合而引发的“血案”

Posted 守夜人爱吃兔子

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Java HashMap详解:一场由于不懂Map集合而引发的“血案”相关的知识,希望对你有一定的参考价值。

故事背景

我们公司的 JDK 是 1.7 版本,最近新上线了一个服务,但是我们发现我们的服务时常会卡死。经过我们的分析,一件可怕的事情浮出了水面......

哈哈,标题虽然有些"标题党"。但是内容绝对是相当的干货。在接下来的文章中我会带领大家深入了解 Map 集合,然后讲解是什么引发的"血案"。

在 Java 的 Collection 集合中,我们不可避免的要用到 Map 集合。那么,问题来了。你够深刻的理解 Java 的 Map 集合吗?

 

什么是 Map

时间复杂度

首先,如果你学过计算机相关专业课程。你就会了解过一个学术名词。它叫做时间复杂度。说白了,时间复杂度就是在计算机内执行一个算法,从开始到获取一个结果所需要耗费时间的一种通用描述。它使用 大 O 符号表示法 来表示 ( 即 T(n) = O(f(n)) )。例如我们常见的一个循环:

// 伪代码

for(i=1; i<=n; ++i)   // 第一行
{
   arr[i] = i;     // 第二行
}

它的时间复杂度怎么算出来呢?

  • 代码第一行只会执行一次。则所耗时间为 1 。
  • 代码第二行会执行 n 次。则所耗时间为 n 。

那么,总时间为 1 + n 。我们带入公式。该方法的时间复杂度 T( n ) = O( 1+n ),从这个结果可以看出来,该算法的耗时随着 n 的不断变化而变化。则按照数学逻辑可以将其简写为 T( n ) = O ( n )。

 


HashMap

为了使得一个数据结构可以将平均插入、查找、删除时间复杂度都为O( 1 ),Hash 表应运而生,而 HashMap 就是 Hash 表的标准实现。

 

Hash 表结构

Hash 表由 Hash桶+ 链表实现。

 

什么是 HashMap

简单点说,就是对传入的 key 做一个 hash 运算,然后找到相应的 hash 桶,把值丢进去。如果里面有其他值的话,就把桶内变成链表结构,如下图。

 

Hash 表有多重要

由于该结构的插入、查找、删除的时间复杂度低。致使其应用广泛。具体有多重要呢?

我们可以看一下 Java 世界中的先祖 Object 类,

 

 

Object 一共就这么几个方法,其中两个方法就是为了 hash 表所量身定制的。

 

equals & hashCode 约定

首先,我们来简单讲解一下什么是 equals & hashCode 约定。

  • 一个对象的 hashCode 必须永远一致。
  • 如果对象 A 和对象 B 调用 equals 方法不相等,允许它们调用 hashCode 方法返回的值相等。但是不推荐这样做,这样会影响内部 Hash 表的查找速度。
  • 如果对象 A 和对象 B 调用 equals 方法相等,那么它们调用 hashCode 方法也一定返回相同值。

 

如何计算 hash 值

在 Java 世界中,当你需要往 HashMap 里面存入数据的时候,JVM 会帮你调用该对象的 hashCode 方法来计算获取其 hash 值,按理说正常是不会有什么奇奇怪怪的问题。 但是总有人喜欢玩一些 "骚操作"。从而违反了上述约定。

那么违反约定会引起什么问题呢 ?

我们分开来看一下。

 

对象消失之谜

如果你违反了上面的第 1 条约定。那么你将会发现你的对象莫名的消失了。

实例代码:

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

class Scratch {

    private String name;
    private String nickName;

    public Scratch(String name, String nickName) {
        this.name = name;
        this.nickName = nickName;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Scratch scratch = (Scratch) o;
        return Objects.equals(name, scratch.name) && Objects.equals(nickName, scratch.nickName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name + nickName);  // 错误的写法  	
    }

    public static void main(String[] args) {
        Scratch numberOne = new Scratch("1号技师", "阿水");
        Scratch numberTwo = new Scratch("2号技师", "阿旺");
        Map<Scratch, String> testMap = new HashMap<>();
        testMap.put(numberOne, "我是1号技师");
        testMap.put(numberTwo, "我是2号技师");
        System.out.println(" ------ 现在开始发言  -------");
        System.out.println(testMap.get(numberOne));
        System.out.println(testMap.get(numberTwo));
        numberTwo.setNickName("李四");
        System.out.println(" ------ 现在开始第二轮发言  -------");
        System.out.println(testMap.get(numberOne));
        System.out.println(testMap.get(numberTwo));
    }
}

你猜,它会打印返回什么 ?

 

很不幸,二号技师丢失了。

【 原因 】

在放入 HashMap 之前 JVM 需要调用该对象的 hashCode 方法。由于我们错误的重写和后面对内部属性的修改。导致 HashMap 得到的是不一样的 hash 值,导致我们找不到我们想要的对象了。

 

你太慢了!

其实如果你违反了第 2 条约定。不会有太大的问题,代码可以正常运行。但是 Map 所具有的性能优势则没有了,如下面这个代码。

class Scratch {

    @Override
    public int hashCode() {
        return 1;  // 错误的写法  
    }

}

如果你每个对象的 hashCode 都为 1。则每次都会出现 hash 碰撞,导致所有值都会落在在一个 hash 桶内。此时,hashmap 将退化成链表。查询的时间复杂度将提升为 O( n )。

如图所示:

 

我是复制人

如果你违反了约定 3。 那么,我只能说,祝你好运。

class Scratch {

    private String name;
    private String nickName;

    public Scratch(String name, String nickName) {
        this.name = name;
        this.nickName = nickName;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    @Override
    public boolean equals(Object o) {
        Scratch o1 = (Scratch) o;
        return (name + nickName).equals(o1.name + o1.nickName); // 错误的写法 
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, nickName);
    }

    public static void main(String[] args) {
        Scratch numberOne = new Scratch("1号技师", "阿水");
        Map<Scratch, String> testMap = new HashMap<>();
        testMap.put(numberOne, "我是1号技师");
        numberOne.setNickName("张三");
        testMap.put(numberOne, "我还是2号技师");
        System.out.println(testMap.get(numberOne));
    }
}

它的运行结果为:

 

到这,看起来没什么不对的问题。但是!当我修改一下代码。你便会发现一个惊人的秘密......

public static void main(String[]args){
        Scratch numberOne=new Scratch("1号技师","阿水");
        Map<Scratch, String> testMap=new HashMap<>();
        testMap.put(numberOne,"我是1号技师");
        numberOne.setNickName("张三");
        testMap.put(numberOne,"我是2号技师");
        System.out.println(testMap.get(numberOne));
        numberOne.setNickName("阿水");
        System.out.println(testMap.get(numberOne));
        }

它的运行结果为:

 

这是怎么个情况?我灰太狼又回来了?没有对 map 进行 put 操作,我们便得到之前的对象。下面由我来解答这个问题,真相只有一个!( 此时柯南背景音乐响起 )

hashmap 在添加元素时的步骤如下:

  • 调用 hashCode 方法获取其 hash 值,然后定位到桶的位置。
  • 如果这个位置上没有元素,我们将直接存储起来。
  • 如果这个位置上有元素,将会调用 equals 方法进行比较,如果相同则更新该元素。如果不同,则新增。

所以,原因便是:由于我们错误的设置了 equals 方法。导致每次判断都是一个新元素,将会不断的新增。最后导致非常大的内存占用问题。

( 柯南背景音乐结束 )

 

为什么容量必须是 2 的幂?(其实知道并无luǎn用,但是面试官还老爱问 )

容量是 2 的幂?这是谁规定的?

我们都知道 Java 的 Collection 集合是提前被封装好的,会自动进行扩容。基本都是内部有一个类似于 MAXIMUM_CAPACITY 的参数来定义的。如果超过该大小的临界值 DEFAULT_LOAD_FACTOR 将会被自动扩容。

但是如果你预先便知道大约有多少数据,则可以调用构造函数来指定其大小,省略了扩容的操作( 毕竟扩容也很复杂 )。

源码方法签:

/**
 * Constructs an empty <tt>HashMap</tt> with the specified initial
 * capacity and the default load factor (0.75).
 *
 * @param  initialCapacity the initial capacity.
 * @throws IllegalArgumentException if the initial capacity is negative.
 */
public HashMap(int initialCapacity)

但是,你不知道的是,Java 会在内部偷偷的帮你取成 2 的幂。源码如下:


/**
 * Returns a power of two size for the given target capacity.
 */
static final int tableSizeFor(int cap){
     int n=cap-1;
     n|=n>>>1;
     n|=n>>>2;
     n|=n>>>4;
     n|=n>>>8;
     n|=n>>>16;
     return(n< 0)?1:(n>=MAXIMUM_CAPACITY)?MAXIMUM_CAPACITY:n+1;
}

何等的骚操作啊。为了压榨性能,提升 CPU 处理速度,采取全部为位运算。在这里我们不去深究该方法,只需了解它会帮你取成 2 的幂。

 

那么,为什么非要把它取成 2 的幂呢?

因为 Hash 表内是有 Hash 桶的,为了快速寻找是第几个桶,取成 2 的幂是最快方式。

源码:

 /**
 * Computes key.hashCode() and spreads (XORs) higher bits of hash
 * to lower.  Because the table uses power-of-two masking, sets of
 * hashes that vary only in bits above the current mask will
 * always collide. (Among known examples are sets of Float keys
 * holding consecutive whole numbers in small tables.)  So we
 * apply a transform that spreads the impact of higher bits
 * downward. There is a tradeoff between speed, utility, and
 * quality of bit-spreading. Because many common sets of hashes
 * are already reasonably distributed (so don't benefit from
 * spreading), and because we use trees to handle large sets of
 * collisions in bins, we just XOR some shifted bits in the
 * cheapest possible way to reduce systematic lossage, as well as
 * to incorporate impact of the highest bits that would otherwise
 * never be used in index calculations because of table bounds.
 */
static final int hash(Object key){
     int h;
     return(key==null)?0:(h=key.hashCode())^(h>>>16);
}

该方法取得该对象的 hashCode 后计算与其本身无符号右移 16 位的异或来获取桶编号。以此来解决 hash 冲撞的问题。

 

Java 1.7 的问题

经过了这么长时间的铺垫,现在我们来讲一讲由 Java 1.7 的 HashMap 引发的血案。

 

Java Hashmap 死循环

【 原因 】

因小 A 在项目中不慎在多线程环境下使用了 Hashmap,导致了 CPU 一直占用 100%,经过仔细排查,发现了该问题。其具体原因如下:

首先,由于 Hashmap 是一个非线程安全的容器。所以它的内部实现并未对多线程环境下进行了兼容。这就导致在多线程环境下进行扩容转移链表时发生死循环状态。其步骤具体如下:

这是一个原始的 Hashmap, 在插入一个新节点时触发了 rehash 方法,进行重新分配 hash 桶。其实现的方法为遍历所有的节点并重新计算 hash 值。但是,这不是有序的。

 

步骤一:两个线程并发在执行。首先,他们都获得了所有节点的集合。该方法内记录了第一个获取到的节点元素 1 和它的 next 元素,元素 2。 然后在线程 1 的时间片区里。对所有的元素进行了重新分配。这里注意由于链表是头节点插入方式,所以顺序是反序的。如下图。

 

步骤二:线程 1 还没来得及将更分配好的值变成新的 table 就过了 CPU 的时间片。现在轮到线程 2 开始遍历。然后继续执行步骤。

 

步骤三:线程 2 获取了元素 1 以后,将把元素 1 挂到 4 号桶,而后获取之前已经记录的 next 节点,也就是元素 2。此时发现元素 2 指向的是 1 ,就又将 元素 1 挂在了元素 2 上。从而形成了一个循环。最终如下:

 

如果是线程 2 先执行完毕更新 table 的话,还有可能导致元素 3 的丢失。

现在,你只要在 get 元素时走入了这个链表,就会引发死循环。导致 CPU 100%。

【 解决办法 】

解决办法很简单。心里默念三遍:

HashMap 不是线程安全的!!

HashMap 不是线程安全的!!

HashMap 不是线程安全的!!

如果要在多线程环境下使用 Map 集合,可以无脑使用 ConcurrentHashMap,该容器是一个线程安全的容器。我们将会在以后介绍多线程的时候讲解。

 

总结

本篇文章花费大篇幅来讲解了什么是时间复杂度、HashMap 的结构、不遵守约定的后果、面试官常问的"为什么容量必须是 2 的幂"的问题和 由于错误使用 HashMap 导致 CPU 跑满的"血案"。

感谢你可以阅读到这里,如果文章对你有所帮助的话,麻烦帮忙一键三连支持一下,我会持续更新java干货分享给大家。祝各位万事胜意,来日可期!

 

 

以上是关于Java HashMap详解:一场由于不懂Map集合而引发的“血案”的主要内容,如果未能解决你的问题,请参考以下文章

Java HashMap详解

java如何对map进行排序详解(map集合的使用)

List,Set和Map详解及其区别和他们分别适用的场景

List,Set和Map详解及其区别和他们分别适用的场景

Java 中Map接口的详解

Java类集总结之二