总阅读量:次

⭐⭐⭐ Spring Boot 项目实战 ⭐⭐⭐ Spring Cloud 项目实战
《Dubbo 实现原理与源码解析 —— 精品合集》 《Netty 实现原理与源码解析 —— 精品合集》
《Spring 实现原理与源码解析 —— 精品合集》 《MyBatis 实现原理与源码解析 —— 精品合集》
《Spring MVC 实现原理与源码解析 —— 精品合集》 《数据库实体设计合集》
《Spring Boot 实现原理与源码解析 —— 精品合集》 《Java 面试题 + Java 学习指南》

摘要: 原创出处 jianshu.com/p/8377e09971b8 「LittleMagic」欢迎转载，保留摘要，谢谢！

🙂🙂🙂关注**微信公众号：【芋道源码】**有福利：

  1. RocketMQ / MyCAT / Sharding-JDBC 所有源码分析文章列表
  2. RocketMQ / MyCAT / Sharding-JDBC 中文注释源码 GitHub 地址
  3. 您对于源码的疑问每条留言都将得到认真回复。甚至不知道如何读源码也可以请教噢。
  4. 新的源码解析文章实时收到通知。每周更新一篇左右。
  5. 认真的源码交流微信群。

为了防止歧义，可以换个说法：Java对象实例和数组元素都是在堆上分配内存的吗？ 答：不一定。满足特定条件时，它们可以在（虚拟机）栈上分配内存。

JVM内存结构很重要，多多复习

这和我们平时的理解可能有些不同。虚拟机栈一般是用来存储基本数据类型、引用和返回地址的，怎么可以存储实例数据了呢？这是因为Java JIT（just-in-time）编译器进行的两项优化，分别称作逃逸分析（escape analysis）和标量替换（scalar replacement）。JIT是个复杂的话题，本文不赘述，看官如果想进一步了解的话，可以参考这篇文章，它里面提供了几篇有用的参考资料。

注意看一下JIT的位置

中文维基上对逃逸分析的描述基本准确，摘录如下：

在编译程序优化理论中，逃逸分析是一种确定指针动态范围的方法——分析在程序的哪些地方可以访问到指针。当一个变量（或对象）在子程序中被分配时，一个指向变量的指针可能逃逸到其它执行线程中，或是返回到调用者子程序。 如果一个子程序分配一个对象并返回一个该对象的指针，该对象可能在程序中被访问到的地方无法确定——这样指针就成功“逃逸”了。如果指针存储在全局变量或者其它数据结构中，因为全局变量是可以在当前子程序之外访问的，此时指针也发生了逃逸。 逃逸分析确定某个指针可以存储的所有地方，以及确定能否保证指针的生命周期只在当前进程或线程中。

简单来讲，JVM中的逃逸分析可以通过分析对象引用的使用范围（即动态作用域），来决定对象是否要在堆上分配内存，也可以做一些其他方面的优化。

以下的例子说明了一种对象逃逸的可能性。

static StringBuilder getStringBuilder1(String a, String b) {
  StringBuilder builder = new StringBuilder(a);
  builder.append(b);
  return builder;   // builder通过方法返回值逃逸到外部
}

static String getStringBuilder2(String a, String b) {
  StringBuilder builder = new StringBuilder(a);
  builder.append(b);
  return builder.toString();  // builder范围维持在方法内部，未逃逸
}

以JDK 1.8为例，可以通过设置JVM参数-XX:+DoEscapeAnalysis、-XX:-DoEscapeAnalysis来开启或关闭逃逸分析（默认当然是开启的）。下面先写一个没有对象逃逸的例子。

public class EscapeAnalysisTest {
  public static void main(String[] args) throws Exception {
    long start = System.currentTimeMillis();
    for (int i = 0; i < 5000000; i++) {
      allocate();
    }
    System.out.println((System.currentTimeMillis() - start) + " ms");
    Thread.sleep(600000);
  }

  static void allocate() {
    MyObject myObject = new MyObject(2019, 2019.0);
  }

  static class MyObject {
    int a;
    double b;

    MyObject(int a, double b) {
      this.a = a;
      this.b = b;
    }
  }
}

然后通过开启和关闭DoEscapeAnalysis开关观察不同。

  • 关闭逃逸分析

~ java -XX:-DoEscapeAnalysis EscapeAnalysisTest
76 ms
~ jmap -histo 26031
 num     #instances         #bytes  class name
----------------------------------------------
   1:       5000000      120000000  me.lmagics.EscapeAnalysisTest$MyObject
   2:           636       12026792  [I
   3:          3097        1524856  [B
   4:          5088         759960  [C
   5:          3067          73608  java.lang.String
   6:           623          71016  java.lang.Class
   7:           727          43248  [Ljava.lang.Object;
   8:           532          17024  java.io.File
   9:           225          14400  java.net.URL
  10:           334          13360  java.lang.ref.Finalizer
# ......

  • 开启逃逸分析

~ java -XX:+DoEscapeAnalysis EscapeAnalysisTest
4 ms
~ jmap -histo 26655
 num     #instances         #bytes  class name
----------------------------------------------
   1:           592       11273384  [I
   2:         90871        2180904  me.lmagics.EscapeAnalysisTest$MyObject
   3:          3097        1524856  [B
   4:          5088         759952  [C
   5:          3067          73608  java.lang.String
   6:           623          71016  java.lang.Class
   7:           727          43248  [Ljava.lang.Object;
   8:           532          17024  java.io.File
   9:           225          14400  java.net.URL
  10:           334          13360  java.lang.ref.Finalizer
# ......

可见，关闭逃逸分析之后，堆上有5000000个MyObject实例，而开启逃逸分析之后，就只剩下90871个实例了，不管是实例数还是内存占用都只有原来的2%不到。另外，如果把堆内存限制得小一点（比如加上-Xms10m -Xmx10m），并且打印GC日志（-XX:+PrintGCDetails）的话，关闭逃逸分析还会造成频繁的GC，开启逃逸分析就没有这种情况。这说明逃逸分析确实降低了堆内存的压力。

但是，逃逸分析只是栈上内存分配的前提，接下来还需要进行标量替换才能真正实现。

所谓标量，就是指JVM中无法再细分的数据，比如int、long、reference等。相对地，能够再细分的数据叫做聚合量。仍然考虑上面的例子，MyObject就是一个聚合量，因为它由两个标量a、b组成。通过逃逸分析，JVM会发现myObject没有逃逸出allocate()方法的作用域，标量替换过程就会将myObject直接拆解成a和b，也就是变成了：

static void allocate() {
  int a = 2019;
  double b = 2019.0;
}

可见，对象的分配完全被消灭了，而int、double都是基本数据类型，直接在栈上分配就可以了。所以，在对象不逃逸出作用域并且能够分解为纯标量表示时，对象就可以在栈上分配。

JVM提供了参数-XX:+EliminateAllocations来开启标量替换，默认仍然是开启的。显然，如果把它关掉的话，就相当于禁止了栈上内存分配，只有逃逸分析是无法发挥作用的。在Debug版JVM中，还可以通过参数-XX:+PrintEliminateAllocations来查看标量替换的具体情况。

除了标量替换之外，通过逃逸分析还能实现同步消除（synchronization elision），当然它与本文的主题无关了。举个例子：

private void someMethod() {
  Object lockObject = new Object();
  synchronized (lockObject) {
    System.out.println(lockObject.hashCode());
  }
}

lockObject这个锁对象的生命期只在someMethod()方法中，并不存在多线程访问的问题，所以synchronized块并无意义，会被优化掉：

private void someMethod() {
  Object lockObject = new Object();
  System.out.println(lockObject.hashCode());
}

累了，晚安晚安。

文章目录