如果面试官问你布隆过滤器，你该怎么回答？

Posted 2023-04-12

参考技术A 假设遇到这样一个问题：一个网站有 20 亿 url 存在一个黑名单中，这个黑名单要怎么存？若此时随便输入一个 url，你如何快速判断该 url 是否在这个黑名单中？并且需在给定内存空间（比如：500M）内快速判断出。

可能很多人首先想到的会是使用 HashSet，因为 HashSet基于 HashMap，理论上时间复杂度为：O(1)。达到了快速的目的，但是空间复杂度呢？URL字符串通过Hash得到一个Integer的值，Integer占4个字节，那20亿个URL理论上需要：20亿*4/1024/1024/1024=7.45G的内存，不满足空间复杂度的要求。

这里就引出本文要介绍的“布隆过滤器”。

百科上对布隆过滤器的介绍是这样的：
布隆过滤器（Bloom Filter）是1970年由布隆提出的。它实际上是一个很长的二进制向量和一系列随机映射函数。布隆过滤器可以用于检索一个元素是否在一个集合中。它的优点是空间效率和查询时间都比一般的算法要好的多，缺点是有一定的误识别率和删除困难。
是不是描述的比较抽象？那就直接了解其原理吧！

还是以上面的例子为例：

哈希算法得出的Integer的哈希值最大为：Integer.MAX_VALUE=2147483647，意思就是任何一个URL的哈希都会在0~2147483647之间。

那么可以定义一个2147483647长度的byte数组，用来存储集合所有可能的值。为了存储这个byte数组，系统只需要：2147483647/8/1024/1024=256M。

比如：某个URL（X）的哈希是2，那么落到这个byte数组在第二位上就是1，这个byte数组将是：000….00000010，重复的，将这20亿个数全部哈希并落到byte数组中。

判断逻辑

如果byte数组上的第二位是1，那么这个URL（X）可能存在。为什么是可能？因为有可能其它URL因哈希碰撞哈希出来的也是2，这就是误判。

但是如果这个byte数组上的第二位是0，那么这个URL（X）就一定不存在集合中。

多次哈希

为了减少因哈希碰撞导致的误判概率，可以对这个URL（X）用不同的哈希算法进行N次哈希，得出N个哈希值，落到这个byte数组上，如果这N个位置没有都为1，那么这个URL（X）就一定不存在集合中。

Guava框架提供了布隆过滤器的具体实现：BloomFilter，使得开发不用再自己写一套算法的实现。

BloomFilter提供了几个重载的静态 create方法来创建实例：

最终还是调用：

真正的byte数组维护在类：BitArray中。

最后通过：put和 mightContain方法，添加元素和判断元素是否存在。

1、因使用哈希判断，时间效率很高。空间效率也是其一大优势。
2、有误判的可能，需针对具体场景使用。
3、因为无法分辨哈希碰撞，所以不是很好做删除操作。

1、黑名单
2、URL去重
3、单词拼写检查
4、Key-Value缓存系统的Key校验
5、ID校验，比如订单系统查询某个订单ID是否存在，如果不存在就直接返回。

面试官问你 JVM，你知道加分项在哪吗？

引言

在面试别人的过程中，​​JVM 内存模型​​​几乎必问，虽然有人说问这些就是​​面试造航母，工作拧螺丝​​。如果你想当一名 CRUD 码农，你可以选择不用了解这些。

在 JVM 内存模型的问答中，有些人能说出对象是在堆上分配的。但当我问对象一定是在堆上存储的嘛时，大部分人都回答是，或者犹豫了。

其实能回答出对象是在堆上分配存储已算正确了。但随着 ​​JIT​​​ 即时编译器的发展和逃逸分析技术的逐渐成熟，所有对象都分配到堆上也逐渐变得不那么绝对了。​​栈上分配​​​，​​标量替换​​​，​​锁消除​​等优化技术会发生一些微妙的变化。

我们知道，我们编写的 Java 源代码通过 ​​javac​​ 编译成字节码文件，然后类加载器将字节码文件加载到内存中，JVM 逐行读取解释字节码翻译成对应的机器指令执行。很明显，解释执行比那些可直接执行的二进制程序（例如 C 语言程序）慢得多。

所以为了提高效率，引入了 JIT （即时编译器）优化技术。Java 程序还是会通过解释器进行解释执行，但是如果某个方法或者代码块运行比较频繁的时候，JVM 认为这是​​热点代码​​，然后将热点代码翻译成本地机器指令，并且进行优化，缓存起来，下次再运行此段代码的时候直接运行而不用再解释。

JIT 中一个很重要的优化技术就是逃逸分析（Escape Analysis）。

逃逸分析

逃逸分析，其实就是分析一个对象是否会逃逸出方法，分析对象的动态作用域。如果一个对象在一个方法内定义，并且有可能被方法外部引用使用，那认为它逃逸了。

例如以下的 person 对象就发生了逃逸，即有可能会被方法外部引用。

public Person personEscape() 
  Person person = new Person();
  return person;

所以为什么要进行逃逸分析，其实最终目的就是为程序做优化，提高运行性能。有如下优化技术点：

• 栈上分配
• 标量替换
• 锁消除

JDK1.7 开始，逃逸分析默认是开启的，可以通过以下参数进行启停。

# 开启
-XX:+DoEscapeAnalysis
# 关闭
-XX:-DoEscapeAnalysis

栈上分配

如果分析一个对象没有逃逸出方法的时候，就有可能被分配到栈上。这样就不需要在堆中进行 GC 回收，提高了性能。

package com.chenpi;

/**
 * @Description
 * @Author 陈皮
 * @Date 2021/7/14
 * @Version 1.0
 */
public class EscapeAnalysisTest 

  public static void main(String[] args) 

    long startTime = System.currentTimeMillis();

    for (int i = 0; i < 10000000; i++) 
      stackAlloc();
    

    System.out.println((System.currentTimeMillis() - startTime) + "ms");
  

  public static void stackAlloc() 
    Person person = new Person("陈皮", 18);
  



class Person 

  private String name;
  private long age;

  public Person(String name, long age) 
    this.name = name;
    this.age = age;
  

虚拟机参数设置开启逃逸分析，并且打印 GC 日志。

-Xms200m -Xmx200m -XX:+DoEscapeAnalysis -XX:+PrintGC

运行程序结果如下，消耗只需要 10 ms，并且没有 GC 。

10ms

关闭逃逸分析，并且打印 GC 日志。

-Xms200m -Xmx200m -XX:-DoEscapeAnalysis -XX:+PrintGC

运行程序结果如下，消耗时间增加了10多倍，并且伴随着多次的 GC 。

[GC (Allocation Failure)  51712K->784K(196608K), 0.0050396 secs]
[GC (Allocation Failure)  52496K->784K(196608K), 0.0030730 secs]
[GC (Allocation Failure)  52496K->752K(196608K), 0.0013993 secs]
[GC (Allocation Failure)  52464K->720K(196608K), 0.0018371 secs]
176ms

标量替换

• 标量：不可再分解成更小数据的类型，例如基本数据类型就是标量。
• 聚合量：可以再分解成其他聚合量或者标量的数据类型，例如对象引用类型。

如果一个对象不会发生逃逸，那么 JIT 可以优化把这个对象分解成若干个标量来代替。这就是标量替换。

public void scalarReplace() 
  Coordinates coordinates = new Coordinates(105.10, 80.22);
  System.out.println(coordinates.longitude);
  System.out.println(coordinates.latitude);

以上演示程序，coordinates 对象不会发生逃逸，所以 JIT 编译器可以使用标量替换进行优化。最终被优化成如下程序。

public void scalarReplace() 
  System.out.println(105.10);
  System.out.println(80.22);

其实在现有的虚拟机中，并没有真正的实现栈上分配，其实是通过标量替换来实现的。

锁消除

为什么要消除锁呢？因为加锁会降低性能，那如何不用加锁是最好的。如果分析出加锁的对象不会发生逃逸，即只能被一个线程访问，JIT 是可以优化消除这个锁的。也称为同步省略。

public void lockRemove() 
  synchronized (new Object()) 
    System.out.println("我是陈皮！");
  

以上演示程序，Object 对象不会发生逃逸，所以也只能当前线程访问到，所以 JIT 编译器可以进行优化锁消除。最终被优化成如下程序。

public void lockRemove() 
  System.out.println("我是陈皮！");

总结

但随着 ​​JIT​​ 即时编译器的发展和逃逸分析技术的逐渐成熟，所有对象都分配到堆上也逐渐变得不那么绝对了。通过逃逸分析技术，对象可能被分配到栈上，能减少 GC，提高程序性能。

但是开启逃逸分析的程序的性能一定高于没有开启逃逸分析的性能吗？其实不一定。逃逸分析技术其实也是很复杂的，所以也是一个会耗时的过程，如果经过逃逸分析之后，发现所有对象都逃逸了，就不能做优化处理，那这个逃逸分析的过程就消耗了时间，还不起优化作用，得不偿失。