禅与计算机
sharkchili
2022-12-13
目录

逃逸分析在Java中的应用与优化

# 写在文章开头

近期文章收到笔者的指正，对于逃逸分析这一模块没有对方法逃逸和线程逃逸进行详尽说明和代码分析，遂以此文针对以下内容进行补充拓展：

  1. 什么是方法逃逸和线程逃逸？两者区别是什么？
  2. 方法逃逸会做那些优化？线程逃逸呢？
  3. 针对多场景演示方法逃逸和线程逃逸之间的区别，并通过字节码进行印证。

Hi，我是 sharkChili ，是个不断在硬核技术上作死的技术人，是 CSDN的博客专家 ，也是开源项目 Java Guide 的维护者之一，熟悉 Java 也会一点 Go ，偶尔也会在 C源码 边缘徘徊。写过很多有意思的技术博客，也还在研究并输出技术的路上，希望我的文章对你有帮助，非常欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

逃逸分析技术算是在JVM面试题偶有提及的一个考察点，当然如果你能够讲解JVM工作原理的时候提及这一点，这一定会增加面试官对你的好感，通过对本篇文章的阅读，你将能够从容的解决以下几个面试题：

  1. 什么是逃逸分析技术？
  2. 逃逸分析技术解决什么问题？带来什么好处？
  3. 如何更好的理解或者运用逃逸分析技术？

# 什么是逃逸分析

逃逸分析技术是JVM用于提高性能以及节省内存的手段，在JVM编译语境下也就是我们常说的JIT阶段，关于逃逸分析的概念，引用《深入理解Java虚拟机》的说法：

逃逸分析的基本原理是:分析对象动态作用域，当一个对象在方法里面被定义后，它可能被外部方法所引用，例如作为调用参数传递到其他方法中，这种称为方法逃逸;甚至还有可能被外部线程访问到，譬如赋值给可以在其他线程中访问的实例变量，这种称为线程逃逸;从不逃逸、方法逃逸到线程逃逸，称为对象由低到高的不同逃逸程度。

只要编译阶段判定当前对象并没有发生逃逸，那么它就会采用栈上分配、标量替换、同步锁消除等手段提升程序执行性能和节省内存开销，具体场景还得查看是发生方法逃逸还是线程逃逸。

那么我们又该如何判断对象是否逃逸呢？我们不妨基于上述的判断条件来看看这个示例，假设我们现在有一个user类，我们通过UserService进行初始化，那么请问这段代码是否发生逃逸呢？

public class UserService {

    private User user;

    public void init() {
        user = new User();
        user.setId(RandomUtil.randomInt(10));
        user.setName(RandomUtil.randomString(3));
    }
}
1
2
3
4
5
6
7
8
9
10
11

答案当然是肯定的，因为这段代码方法内所创建的对象被外部的main函数所引用，也就是我们所说的方法逃逸。

再来看看这段代码，典型的在方法内创建然后被外部函数所引用，也就是所谓的方法逃逸：

public User createUser() {
        User user = new User();
        user.setId(RandomUtil.randomInt(10));
        user.setName(RandomUtil.randomString(3));
        return user;
    }
1
2
3
4
5
6

而这段stringBuffer 已经被其他线程实例所访问到，也就是典型的线程逃逸：

public static void main(String[] args) throws InterruptedException {
        StringBuffer stringBuffer = new StringBuffer();
        CountDownLatch countDownLatch = new CountDownLatch(3);
        //调用appendStr操作stringBuffer
        new Thread(() -> {
            appendStr(stringBuffer);
            countDownLatch.countDown();
        }).start();

        //循环拼接操作stringBuffer
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                stringBuffer.append("aaa");
            }
            countDownLatch.countDown();
        }).start();
        
        //循环拼接操作stringBuffer
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                stringBuffer.append("aaa");
            }
            countDownLatch.countDown();
        }).start();

        countDownLatch.await();
        System.out.println(stringBuffer);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

# 如何运用到逃逸分析技术

# 栈上分配（针对未逃逸或方法逃逸）

下面这段代码仅在方法内部完成对象创建或者打印，其对象并没有被外部方法所引用和暴露，对象就没有发生逃逸，对于没有发生逃逸的代码或者上文中方法逃逸的代码端，JIT会通过栈上分配减少内存占用和GC压力。

	Map<Integer, User> userMap = new HashMap<>();


    public int getUserAgeById(int id) {
      	User user = new User();
        user.setId(RandomUtil.randomInt(10));
        user.setName(RandomUtil.randomString(3));
        //打印用户信息
        printUserInfo(user);
    }
1
2
3
4
5
6
7
8
9
10

# 分离对象或标量替换(针对未逃逸)

如果仅仅是操作未逃逸对象的某些简单运算，我们同样可以只在栈帧内使用这个对象，如此JVM就会将这个对象打散，将对象打散为无数个小的局部变量，实现标量替换。

如下所示，这段代码没有发生任何逃逸，JVM会避免创建Point ，而是通过栈上创建基本变量完成逻辑操作：

public static void main(String args[]) {
    alloc();
}
class Point {
    private int x;
    private int y;
}
private static void alloc() {
    Point point = new Point(1,2);
    System.out.println("point.x" + point.x + ";point.y" + point.y);
}
1
2
3
4
5
6
7
8
9
10
11

进而直接标量替换，直接在栈上分配x和y的值，完成输出打印。

private static void alloc() {
    int x = 1;
    int y = 2;
    System.out.println("point.x = " + x + "; point.y=" + y);
}
1
2
3
4
5

# 同步锁消除(针对未逃逸线程)

这一点就比较有趣了，我们都知道使用StringBuffer可以保证线程安全，因为其操作函数都有带synchronized关键字，那么请问这段代码会上锁吗？

public void appendStr(int count) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < count; i++) {
            sb.append("no: " + i + " ");
        }
    }
1
2
3
4
5
6

答案是不会，因为我们当前操作的StringBuffer 对象并没有发生线程逃逸，它仅仅在函数内部进行字符串操作，所以针对appendStr内部逻辑，其直接将其优化为StringBuilder：

# 线程逃逸分析的更进一步

请问实例方法调用静态方法，StringBuffer作为变量传入，是否发生逃逸，直接创建一个main方法调用这段代码，方法是否发生逃逸？

public void appendStr(int count) {
        StringBuffer sb = new StringBuffer();
        loop(count, sb);
    }

    private static void loop(int count, StringBuffer sb) {
        for (int i = 0; i < count; i++) {
            sb.append("no: " + i + " ");
        }
    }
1
2
3
4
5
6
7
8
9
10

答案是发生了方法逃逸，但是没有发生线程逃逸，但我们的代码是单线程执行这段代码，即使StringBuffer 由外部传入，函数内部依然可以进行锁消除将其内部的拼接逻辑用StringBuilder进行字符串拼接：

再来看看这段代码，请问发生逃逸了吗？

 public void appendStr(int count) {
        StringBuffer sb = new StringBuffer();
        loop(count, sb);
    }

    private static String loop(int count, StringBuffer sb) {
        for (int i = 0; i < count; i++) {
            sb.append("no: " + i + " ");
        }
        return sb.toString();
    }
1
2
3
4
5
6
7
8
9
10
11

答案是没有发生线程逃逸，返回的字符串还是没有被外部线程操作，所以最终还是被转为StringBuilder:

而下面这段代码就是典型的逃逸，可以看到多线程场景下StringBuffer 被多线程共享和访问，此时JIT优化就会视为对象逃逸：

public static void main(String[] args) throws InterruptedException {
        StringBuffer stringBuffer = new StringBuffer();
        CountDownLatch countDownLatch = new CountDownLatch(3);
        //调用appendStr操作stringBuffer
        new Thread(() -> {
            appendStr(stringBuffer);
            countDownLatch.countDown();
        }).start();

        //循环拼接操作stringBuffer
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                stringBuffer.append("aaa");
            }
            countDownLatch.countDown();
        }).start();

        //循环拼接操作stringBuffer
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                stringBuffer.append("aaa");
            }
            countDownLatch.countDown();
        }).start();

        countDownLatch.await();
        System.out.println(stringBuffer);
    }

    public static void appendStr(StringBuffer stringBuffer) {
        for (int i = 0; i < 10; i++) {
            stringBuffer.append(i);
        }

    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

所以appendStr在判定线程逃逸之后，并没有将StringBuffer变为StringBuilder：

# 小结

合理的在栈帧上解决问题可以避免对象逃逸，从而让JIT尽可能的去进行优化，这一点我想应该是一个Java程序员对于代码的极致追求了。 我是 sharkchili ，CSDN Java 领域博客专家，mini-redis的作者，我想写一些有意思的东西，希望对你有帮助，如果你想实时收到我写的硬核的文章也欢迎你关注我的公众号： 写代码的SharkChili 。

同时也非常欢迎你star我的开源项目mini-redis:https://github.com/shark-ctrl/mini-redis (opens new window)

因为近期收到很多读者的私信，所以也专门创建了一个交流群，感兴趣的读者可以通过上方的公众号获取笔者的联系方式完成好友添加，点击备注 “加群” 即可和笔者和笔者的朋友们进行深入交流。

# 参考

逃逸分析，yyds！！:https://mdnice.com/writing/0e00579d830d4d519a5f862d2ea08527#:~:text=逃逸分析就是：一,可以访问到指针。 (opens new window)

《深入理解Java虚拟机》

编辑 (opens new window)
上次更新: 2026/03/26, 01:05:31
来聊聊大厂面试常问的指针压缩
从零开始理解JVM的JIT编译机制

← 从零开始理解JVM的JIT编译机制→

最近更新
01
基于EasyExcel实现高效导出
03-25
02
从开源框架中学习那些实用的位运算技巧
03-25
03
浅谈分布式架构设计思想和常见优化手段
03-25
更多文章>
Theme by Vdoing | Copyright © 2025-2026 Evan Xu | MIT License | 桂ICP备2024034950号 | 桂公网安备45142202000030
×
×