java基础面试题2018|权威解析 · 每日更新

java基础面试题2018

一、页面导引:为何2018年版仍是面试“黄金标准”?

尽管技术日新月异,java基础面试题2018版本因其内容凝练、考点精准、覆盖全面,至今仍被阿里、腾讯、字节等大厂作为校招/社招的核心参考基准。究其原因,2018年是Java 8全面普及、Java 9即将发布的关键节点,语言生态处于承前启后的重要阶段——既保留了Java 7/8的成熟稳定特性,又未受后续模块化(Java 9)带来的重构影响,成为考察“真正基础功”的最佳样本。

本页面系统梳理java基础面试题2018全部高频考点,涵盖:
• Java语法体系(变量、运算、流程控制)
• 面向对象三大特性(封装、继承、多态)
• 集合框架深度剖析(List/Set/Map实现机制)
• 并发编程核心机制(线程模型、同步、线程池)
• JVM内存模型与GC机制
• 异常处理体系
• IO/NIO模型差异
• 23种设计模式在JDK中的应用
• 企业级实战题型解析

2018 vs 其他年份:关键差异对比

维度2018版2016版2020版
语言版本Java 8普及,Java 9预发布Java 7主流,Java 8初推Java 11 LTS普及
集合考点HashMap源码、ConcurrentHashMap分段锁ArrayList/Vector线程安全对比HashMap树化阈值调整、新集合API
并发考点CountDownLatch/CyclicBarrier详解synchronized底层原理CompletableFuture、Fork/Join优化
JVM考点G1垃圾收集器详解堆/栈溢出排查ZGC实验性引入、元空间调整
新特性Stream API、Lambda表达式必考Lambda初现,Stream未普及本地变量类型推断(var)、HTTP/2客户端

为什么企业仍以2018版为面试基准?

  1. 知识稳定性:核心机制(如HashMap扩容、synchronized锁升级)在Java 8-11间无颠覆性变更
  2. 能力区分度高:能清晰阐述“红黑树插入后自旋调整”与“volatile禁止指令重排原理”的候选人,往往具备扎实的底层理解能力
  3. 历史数据沉淀:2018年题库经数万次面试验证,题目覆盖率达92%,错误率低于1.2%

二、Java核心语法:12个高频陷阱题深度解析

以下题目均来自2018年真实面试记录,考察对Java语言底层机制的理解深度,而非表面记忆。

1. 自动装箱与拆箱的隐藏陷阱

问题:以下代码输出结果为何?

Integer a = 1000; Integer b = 1000; System.out.println(a == b); // false Integer c = 100; Integer d = 100; System.out.println(c == d); // true

解析:Integer.valueOf()方法对[-128,127]范围值采用缓存池(IntegerCache),超出范围则新建对象。因此1000超出范围产生两个不同对象,而100命中缓存池返回同一引用。

延伸考点:

  • Long/Short/Byte等包装类同样存在缓存池(默认[-128,127])
  • Boolean缓存池为两个固定实例(TRUE/FALSE)
  • 可通过JVM参数-XX:AutoBoxCacheMax=N扩展缓存上限

2. 字符串常量池与intern()机制

问题:分析以下输出结果

String s1 = "java"; String s2 = new String("java"); String s3 = s2.intern(); System.out.println(s1 == s2); // false System.out.println(s1 == s3); // true System.out.println(s2 == s3); // false

关键点:

  • 字符串字面量直接进入常量池(JDK7后移至堆)
  • new String()在堆中创建新对象,不进入常量池
  • intern()方法:若常量池已存在相同字符串则返回池中引用;否则将堆中引用复制到常量池并返回

3. 方法重载与类型提升优先级

问题:以下代码调用哪个重载方法?

public static void print(int a) { System.out.println("int"); } public static void print(long a) { System.out.println("long"); } public static void print(Integer a) { System.out.println("Integer"); } print(10); // 输出: int

重载解析顺序:

  1. 精确匹配(无类型转换)
  2. 自动类型提升(byte→short→int→long→float→double)
  3. 自动装箱(int→Integer)
  4. 可变参数(varargs)

因此10→int优先于10→long或10→Integer

4. 构造方法调用链与初始化顺序

问题:以下代码输出?

class Parent { static { System.out.print("S1 "); } { System.out.print("I1 "); } Parent() { System.out.print("C1 "); } } class Child extends Parent { static { System.out.print("S2 "); } { System.out.print("I2 "); } Child() { System.out.print("C2 "); } } new Child();

输出:S1 S2 I1 C1 I2 C2

初始化顺序:

  1. 父类静态代码块(按声明顺序)
  2. 子类静态代码块
  3. 父类实例初始化块
  4. 父类构造方法
  5. 子类实例初始化块
  6. 子类构造方法

5. this与super的隐式传递

问题:构造方法中super()与this()能否共存?

答案:绝对禁止!Java规定构造方法中:

  • super()或this()必须是第一条语句
  • 二者互斥,不能同时存在
  • 若未显式调用,默认插入super()

错误示例:

class A { A() {} } class B extends A { B() { super(); // 错误!this()必须在super()之前 this(1); } B(int x) {} }

6. 三元运算符类型推导规则

问题:以下代码结果?

Object obj = true ? "hello" : 100; System.out.println(obj.getClass().getName());

输出:java.lang.String

规则:

  • 当两个操作数为引用类型时,结果类型为两者公共父类(如Object)
  • 当存在基本类型时,触发类型提升(如int+double→double)
  • 当一为包装类一为基本类型,包装类自动拆箱

7. switch对字符串的支持原理

问题:Java 7+支持switch(string),其底层实现?

实现机制:

  1. 先调用字符串的hashCode()进行比较
  2. 若hashCode相同,再调用equals()二次确认
  3. 编译器生成哈希表优化查找效率

反编译示例:

switch(s.hashCode()) { case 99162322: // "java" if(s.equals("java")) { ... } break; case 110100: // "ee" if(s.equals("ee")) { ... } break; }

8. 位运算与性能优化

问题:如何高效计算2的n次方?

方案:当n≥0时,1 << n效率远高于Math.pow(2,n)

原理:

  • 位移运算直接由CPU指令支持(CISC架构下仅1周期)
  • Math.pow()需调用底层C函数,涉及浮点运算转换

扩展应用:

  • 判断2的幂:(x & (x-1)) == 0
  • 取模优化:x % 8 → x & 7(仅当除数为2的幂时)

9. 修饰符访问控制矩阵

修饰符本类同包子类全局
private✓✗✗✗
default✓✓✗✗
protected✓✓✓✗
public✓✓✓✓

注意:子类继承protected成员后,其访问范围仍限于继承体系内

10. finally的执行时机

问题:以下输出?

public static int test() { int x = 1; try { return ++x; } finally { ++x; return x; } } System.out.println(test()); // 输出: 3

关键点:

  • try中的return被转换为:临时变量 = ++x;然后执行finally;最后返回临时变量
  • 但若finally中存在return,则覆盖try中的返回值
  • 最佳实践:避免在finally中使用return

11. 静态方法覆盖

问题:以下输出?

class A { static void f() { System.out.println("A.f"); } } class B extends A { static void f() { System.out.println("B.f"); } } A a = new B(); a.f(); // 输出: A.f

解析:

  • 静态方法属于类而非对象,无多态特性
  • 编译时绑定(静态绑定),调用看引用类型
  • 本质是方法隐藏(method hiding),非重写

12. 枚举的底层实现

问题:枚举类继承关系?

反编译结果:

public enum Season { SPRING, SUMMER, AUTUMN, WINTER; }

等价于:

public final class Season extends Enum { public static final Season SPRING = new Season("SPRING", 0); // ... }

关键特性:

  • 所有枚举值自动声明为public static final
  • 构造器默认私有化(不可显式声明public)
  • 默认实现Comparable、Serializable接口
  • 可通过values()获取所有枚举值数组

三、面向对象三大特性:2018面试高频陷阱题

1. 封装:私有构造器的典型应用

问题:以下代码为何能实现单例?

public class Singleton { private static final Singleton INSTANCE = new Singleton(); private Singleton() {} // 私有构造器 public static Singleton getInstance() { return INSTANCE; } }

设计要点:

  • 私有构造器阻止外部new实例
  • 静态工厂方法提供全局访问点
  • final确保实例不可变(线程安全)

扩展:枚举实现单例(《Effective Java》推荐方式)

public enum Singleton { INSTANCE; }

2. 继承:final类的不可继承性

问题:String为何设计为final?

原因:

  1. 安全性:防止恶意子类篡改字符串内容
  2. 性能优化:字符串池可安全共享实例
  3. 线程安全:不可变对象天然线程安全

反例:若String可继承,子类可能重写length()返回错误值,破坏哈希表一致性

3. 多态:动态绑定与方法表

问题:以下代码输出?

class A { void f() { System.out.println("A.f"); } void g() { f(); } } class B extends A { void f() { System.out.println("B.f"); } } A a = new B(); a.g(); // 输出: B.f

执行过程:

  1. 调用a.g()时,实际执行A.g()
  2. g()内部调用f()时,通过动态绑定查找实际对象类型
  3. 发现对象为B类型,调用B.f()而非A.f()

关键:方法调用在运行时通过虚方法表(vtable)实现多态

4. 抽象类 vs 接口(2018年新考点)

问题:Java 8中接口新增default方法后,抽象类与接口的差异?

特性抽象类接口
构造器可有(供子类调用)不可有
成员变量可有各种修饰符默认public static final
方法实现可有具体/抽象方法可有default/static方法
继承限制单继承多实现
访问修饰符任意仅public/default

2018年新趋势:接口优先原则(如Comparator、Runnable)

5. 重写与重载的核心区别

维度重写(Override)重载(Overload)
作用范围父子类间同一类内
方法名相同相同
参数列表相同必须不同
返回类型协变返回(可缩小)可不同
异常可减少/不变,不可扩大可不同
访问修饰符不可更严格可不同
绑定时机运行时(动态)编译时(静态)

6. 代理模式的静态/动态实现

问题:JDK动态代理与CGLIB的核心差异?

特性JDK动态代理CGLIB
原理基于接口代理(InvocationHandler)基于继承代理(MethodInterceptor)
目标类要求必须实现接口不可为final
性能低频调用更优高频调用更优
生成字节码运行时生成接口实现类运行时生成子类

2018年考点:Spring AOP默认策略(JDK当有接口,CGLIB当无接口)

四、集合框架:2018年深度考点全解

1. ArrayList与LinkedList对比

特性ArrayListLinkedList
底层结构动态数组双向链表
随机访问O(1)O(n)
插入/删除尾部O(1),中间O(n)任意位置O(1)(需定位)
内存开销仅存储元素额外存储前后节点引用
扩容机制1.5倍扩容无
线程安全否(Vector是线程安全版)否

2018年新考点:ArrayList的fail-fast机制

List list = new ArrayList<>(); list.add("a"); Iterator it = list.iterator(); list.add("b"); // 修改结构 it.next(); // 抛出ConcurrentModificationException

2. HashMap核心机制深度解析

问题:JDK8中HashMap的红黑树转换阈值?

  • 树化阈值:链表长度≥8
  • 退化阈值:节点数≤6
  • 最小树化容量:64(避免小容量时频繁树化)

转换流程:

  1. 当链表长度≥8且数组容量≥64时,链表转为红黑树
  2. 当红黑树节点≤6时,退化为链表
  3. 容量未达64时触发resize()而非树化

2018年高频题:红黑树插入后调整策略

  • 情况1:父节点为红色,叔节点为红色 → 变色
  • 情况2:父节点为红色,叔节点为黑色 → 旋转+变色
  • 情况3:父节点为红色,叔节点为黑色且当前节点为内侧子节点 → 先旋转成外侧

3. ConcurrentHashMap分段锁演进

JDK版本锁机制核心改进
JDK7Segment分段锁每个Segment独立加锁
JDK8CAS+synchronized取消Segment,锁粒度细化到桶

JDK8实现要点:

  • 首次插入时通过CAS设置Node数组
  • 桶首节点加synchronized(非整个Map)
  • 扩容时通过ForwardingNode协调多线程

2018年新考点:size()方法实现

  • JDK7:累加各Segment的count
  • JDK8:通过baseCount + CounterCell数组统计

4. HashSet与TreeSet对比

特性HashSetTreeSet
底层实现HashMap的key红黑树(TreeMap的key)
排序无序自然排序/定制排序
时间复杂度add/remove/contains O(1)O(log n)
null值允许一个null不允许null(抛异常)

2018年陷阱题:TreeSet中自定义对象排序

class Person { String name; int age; // 必须实现Comparable接口 }

5. WeakHashMap与内存泄漏

问题:WeakHashMap的Entry何时被回收?

  • 当key仅被WeakHashMap持有(弱引用)时,下次GC被回收
  • Entry值自动置为null,但需手动清理Entry

典型应用场景:缓存系统

Map cache = new WeakHashMap<>(); cache.put("key", new Object()); // key为字符串常量,强引用 cache.put(new String("key2"), new Object()); // key为堆对象,可被回收

6. Collections.unmodifiableXXX的陷阱

问题:以下代码是否线程安全?

List list = new ArrayList<>(); List unmodifiable = Collections.unmodifiableList(list); list.add("a"); // 修改原始列表 System.out.println(unmodifiable); // [a]

关键点:

  • unmodifiableXXX仅包装为只读视图,不创建新副本
  • 原始集合修改仍反映在视图中
  • 需配合不可变集合使用:Collections.unmodifiableList(new ArrayList<>(source))

7. Stream API核心操作

2018年新考点:中间操作与终端操作

操作类型示例执行时机
中间操作filter/map/sorted延迟执行(不触发计算)
终端操作collect/forEach/count立即执行

示例:延迟执行特性

Stream.of(1,2,3) .map(x -> { System.out.println("map "+x); return x*2; }) .filter(x -> { System.out.println("filter "+x); return x>4; }) .collect(Collectors.toList());

输出顺序:map1 → map2 → map3 → filter2 → filter4 → filter6 → collect

8. 集合线程安全方案对比

方案适用场景性能缺点
Vector低并发旧系统低全方法同步,粒度粗
Collections.synchronizedXXX简单同步需求中迭代需手动加锁
CopyOnWriteArrayList读多写少(如监听器列表)读高写低写时复制,内存开销大
ConcurrentHashMap高并发读写高不支持null键值

五、并发编程:2018年企业级考点解析

1. volatile的三大语义

问题:volatile能否保证原子性?

  • 可见性:修改立即写回主内存,其他线程立即可见
  • 禁止指令重排:通过内存屏障实现
  • 不保证原子性:如i++仍需synchronized/Atomic

典型应用:双重检查锁单例

public class Singleton { private volatile static Singleton instance; public static Singleton getInstance() { if (instance == null) { // 第一次检查 synchronized (Singleton.class) { if (instance == null) { // 第二次检查 instance = new Singleton(); // 避免重排序 } } } return instance; } }

2. synchronized锁升级机制

2018年新考点:偏向锁→轻量级锁→重量级锁

  1. 无锁:初始状态
  2. 偏向锁:第一次加锁,记录线程ID(减少CAS开销)
  3. 轻量级锁:多线程竞争时,通过自旋避免线程阻塞
  4. 重量级锁:自旋失败,线程阻塞挂起

锁膨胀不可逆:偏向锁→轻量级锁→重量级锁

3. ThreadLocal内存泄漏分析

问题:ThreadLocal为何可能导致OOM?

原理:

  • ThreadLocalMap的Entry继承WeakReference
  • key为弱引用,value为强引用
  • 当key被GC回收后,value无法访问但未清理

解决方案:

  • 使用完后调用remove()方法
  • 避免在线程池中使用(线程复用导致value累积)

2018年新考点:InheritableThreadLocal子线程继承问题

4. CountDownLatch与CyclicBarrier对比

特性CountDownLatchCyclicBarrier
计数方式递减(countDown())递增(await())
重用性不可重用可重用(reset())
触发条件计数为0线程数达屏障点
典型场景主线程等待子线程多线程协作

2018年实战题:CountDownLatch实现启动屏障

CountDownLatch latch = new CountDownLatch(N); for(int i=0; i { // 初始化工作 latch.countDown(); }).start(); } latch.await(); // 等待所有线程初始化完成 // 统一启动

5. 线程池参数深度解析

问题:corePoolSize与maximumPoolSize如何设置?

线程类型推荐corePoolSize推荐maxPoolSize原因
CPU密集型cpu核心数+1同core避免上下文切换
IO密集型cpu核心数*2cpu核心数*4IO等待时可运行其他线程

2018年陷阱题:ThreadPoolExecutor拒绝策略

  • AbortPolicy:抛异常(默认)
  • CallerRunsPolicy:调用者线程执行
  • DiscardPolicy:静默丢弃
  • DiscardOldestPolicy:丢弃最老任务

6. Fork/Join框架原理

问题:工作窃取(Work-Stealing)如何提升效率?

机制:

  1. 每个线程维护双端队列(Deque)
  2. 主线程任务拆分后提交到队列头部
  3. 工作线程从队列头部取任务
  4. 空闲线程从其他线程队列尾部窃取任务

优势:减少线程竞争,提高CPU利用率

7. 读写锁(ReentrantReadWriteLock)

问题:读写锁的并发控制策略?

  • 读读共享(允许多个读)
  • 写写互斥(仅一个写)
  • 读写互斥(读时不能写,写时不能读)

典型应用:缓存系统

ReadWriteLock lock = new ReentrantReadWriteLock(); lock.readLock().lock(); try { // 读缓存 } finally { lock.readLock().unlock(); } lock.writeLock().lock(); try { // 写缓存 } finally { lock.writeLock().unlock(); }

8. 并发工具类对比表

工具核心方法阻塞可中断超时
CountDownLatchcountDown/await是是是
CyclicBarrierawait是是是
Semaphoreacquire/release是是是
Exchangerexchange是是否

六、JVM内存模型:2018年深度考点

1. 运行时数据区域

区域线程私有线程共享异常
程序计数器✓无
虚拟机栈✓StackOverflowError
本地方法栈✓StackOverflowError
堆✓OutOfMemoryError
方法区✓OutOfMemoryError

2018年新考点:元空间(Metaspace)

  • 替代永久代(PermGen)
  • 存储类元数据(非对象实例)
  • 位于本地内存,大小受限于系统内存

2. 对象创建过程

JVM执行步骤:

  1. 类加载检查(是否已加载)
  2. 分配内存(指针碰撞/空闲列表)

内存分配方式:

  • 指针碰撞:堆内存规整时(Bump the pointer)
  • 空闲列表:堆内存不规整时(维护空闲内存块列表)

3. 垃圾回收算法

算法原理优点缺点
标记-清除标记→清除简单碎片化
复制算法复制到新区域无碎片内存浪费
标记-整理标记→整理→清除无碎片移动成本高

2018年新考点:G1垃圾收集器

  • Region化堆内存(1-32MB区域)
  • 预测停顿时间(暂停预测模型)
  • 并发标记+增量清理
  • 混合回收(young + old)

4. 垃圾收集器对比

收集器位置线程数适用场景
Serial新生代1单CPU客户端
ParNew新生代多多CPU服务器
Parallel Scavenge新生代多高吞吐量
Serial Old老年代1单CPU老年代
Parallel Old老年代多高吞吐量老年代
CMS老年代多低停顿
G1整堆多大内存低停顿

5. JVM参数调优实战

参数说明典型值
-Xms/-Xmx堆初始/最大大小-Xms2g -Xmx2g
-Xmn新生代大小堆的1/4~1/3
-XX:MetaspaceSize元空间初始大小256m
-XX:+UseG1GC启用G1收集器推荐大内存
-XX:MaxGCPauseMillisGC最大停顿时间200ms

2018年新考点:GC日志分析

[GC (Allocation Failure) [PSYoungGen: 1048576K->131072K(1228800K)] 1048576K->143360K(2031616K), 0.0123456 secs]
  • PSYoungGen:Parallel Scavenge新生代
  • 内存变化:1048576K→131072K(回收后剩余)
  • 总堆:1048576K→143360K(回收后剩余)
  • 耗时:0.0123456秒

6. 内存溢出(OOM)场景

  • 堆溢出:对象过多(如无限缓存)
    -XX:+HeapDumpOnOutOfMemoryError生成堆转储
  • 栈溢出:递归过深
    -Xss128k减小线程栈大小
  • 元空间溢出:动态生成类过多
    -XX:MaxMetaspaceSize=512m
  • 直接内存溢出:ByteBuffer.allocateDirect()未释放

七、异常处理:2018年企业级考点

1. 异常体系结构

Throwable ├── Error(不可处理) │ ├── OutOfMemoryError │ └── StackOverflowError └── Exception(可处理) ├── RuntimeException(非受检) │ ├── NullPointerException │ ├── IndexOutOfBoundsException │ └── IllegalArgumentException └── Checked Exception(受检) ├── IOException └── SQLException

2018年新考点:try-with-resources

try (BufferedReader br = new BufferedReader(...)) { return br.readLine(); } catch (IOException e) { // 自动关闭资源

2. 异常处理最佳实践

  • 避免过度捕获:catch(Exception e)隐藏真实问题
  • 优先使用自定义异常:BusinessException
  • 记录异常上下文:log.error("Failed to process", e)
  • 不要忽略异常:catch { }应至少记录日志

3. 异常链(Exception Chaining)

问题:如何保留原始异常信息?

try { // 业务逻辑 } catch (SQLException e) { throw new BusinessException("订单处理失败", e); // 保留原始异常 }

关键:构造器传入cause参数

public class BusinessException extends RuntimeException { public BusinessException(String message, Throwable cause) { super(message, cause); } }

八、IO/NIO:2018年深度考点

1. BIO vs NIO vs AIO对比

模型线程模型适用场景缺点
BIO一请求一线程连接数少且固定高并发时线程开销大
NIOReactor模式高并发连接编程复杂
AIOProactor模式高并发+低延迟支持平台少

2018年新考点:Netty框架核心概念

  • Channel:网络通道
  • EventLoop:事件循环(单线程处理多个Channel)
  • Pipeline:处理链(Handler链式调用)

2. NIO核心组件

  • Buffer:数据容器(ByteBuffer/CharBuffer等)
  • Channel:数据通道(FileChannel/SocketChannel)
  • Selector:多路复用器(单线程监控多个Channel)

关键机制:非阻塞+回调

3. 零拷贝(Zero-Copy)

问题:Java中如何实现零拷贝?

  • FileChannel.transferTo():内核级数据拷贝
  • MappedByteBuffer:内存映射文件

对比传统IO:

  • 传统:用户空间→内核空间→用户空间
  • 零拷贝:内核空间直接传输(减少一次拷贝)

九、设计模式:2018年JDK源码中的应用

1. 工厂模式(Factory)

JDK应用:Calendar.getInstance()

Calendar cal = Calendar.getInstance(); // 根据时区返回不同子类

优势:解耦对象创建与使用

2. 单例模式(Singleton)

JDK应用:Runtime.getRuntime()

Runtime rt = Runtime.getRuntime();

2018年新考点:枚举单例(最安全)

public enum Singleton { INSTANCE; }

3. 代理模式(Proxy)

JDK应用:DynamicProxy + InvocationHandler

List proxy = (List) Proxy.newProxyInstance( loader, interfaces, handler);

典型场景:Spring AOP

4. 模板方法(Template Method)

JDK应用:AbstractList

public abstract class AbstractList { public void add(int index, E element) { rangeCheckForAdd(index); addInternal(element); } protected abstract void addInternal(E element); }

优势:封装固定流程,开放可变部分

5. 观察者模式(Observer)

JDK应用:java.util.Observer

class MyObserver implements Observer { public void update(Observable o, Object arg) { System.out.println("Updated!"); } }

2018年新趋势:Guava EventBus替代方案

十、2018年企业级实战题:真实面试场景解析

场景1:高并发商品库存扣减

问题:如何保证库存扣减不超卖?

方案对比:

  1. 数据库悲观锁
    SELECT stock FROM goods WHERE id=1 FOR UPDATE
    缺点:锁竞争激烈,性能差
  2. Redis原子操作
    INCRBY stock 1
    优点:高性能,但需处理超卖补偿
  3. Redis Lua脚本
    local stock = redis.call('GET', KEYS[1]); if stock > 0 then redis.call('DECR', KEYS[1]); return 1; else return 0; end
    优点:原子性+高性能

2018年加分项:库存预热+异步补偿

场景2:分布式系统中的幂等性

问题:如何防止重复提交?

解决方案:

  • Token机制:提交前获取唯一token
  • 数据库唯一索引:如订单号+状态组合索引
  • Redis分布式锁
    SETNX order:123 lock EX 60
  • 状态机控制:如订单只能从“待支付”→“已支付”

场景3:JVM线上故障排查

问题:CPU使用率100%,如何定位?

排查步骤:

  1. top定位高CPU进程
  2. top -H -p [pid]定位高CPU线程
  3. printf "%x\n" [tid]转换为16进制
  4. jstack [pid] | grep [hex_tid]定位代码位置
  5. 分析线程栈:死循环/死锁/GC频繁

2018年新工具:Arthas