线上 JVM 实战

一、线上问题排查总原则

线上问题不要一上来就改 JVM 参数、重启服务或调整线程池。建议按照下面的顺序处理:

  1. 确认影响范围:单实例、单机房、单接口,还是整个集群;确认开始时间、持续时间和影响用户。

  2. 先止损:必要时摘除异常实例、限流、关闭非核心功能、暂停异常任务或回滚版本,优先恢复核心业务。

  3. 保留现场:记录实例、PID、容器、时间点、CPU/内存、线程数、GC 指标、错误日志和变更记录。能保留时先保存线程栈、GC 日志和堆信息。

  4. 建立证据链:从监控发现异常,再通过日志、线程栈、GC 日志、堆转储、链路追踪等信息逐步缩小范围。

  5. 验证根因:不能只凭现象下结论。修复后需要观察关键指标是否恢复,并确认没有引入新的问题。

  6. 复盘预防:补充监控、告警、压测、容量评估、超时和重试策略、异常处理与回滚方案。

排查时尤其需要区分:

  • 症状:例如接口变慢、CPU 升高、Full GC 增多。

  • 直接原因:例如线程池队列堆积、对象存活量升高、下游响应变慢。

  • 根本原因:例如流量突增、查询缺少索引、缓存失效策略不合理、线程池容量与业务模型不匹配。

建议先看整体监控,再看单实例;先判断 CPU、内存、网络、磁盘还是下游依赖异常,再选择对应工具。不要在生产环境随意执行高开销命令。

二、JVM 线上实战

1. JVM 内存结构与常见异常

1.1 运行时内存区域

区域 主要用途 常见问题
Java 堆(Heap) 存放对象实例和数组,是 GC 主要管理区域 Java heap space、频繁 GC、对象滞留
程序计数器 记录当前线程执行的字节码位置 通常不需要单独排查
Java 虚拟机栈 保存方法调用栈帧、局部变量等;每个线程通常有自己的栈 StackOverflowError、线程栈相关问题
本地方法栈 为 Native 方法服务 Native 调用相关问题
元空间(Metaspace) 存放类元数据,使用本地内存 Metaspace 溢出、类加载器泄漏
直接内存(Direct Memory) NIO 等使用的堆外内存 Direct buffer memory、进程内存高但堆不高
其他 Native 内存 线程栈、JIT Code Cache、GC 数据结构、JNI 等 容器 OOM、Native Memory 增长

注意:进程使用的总内存不等于 Java 堆内存。容器内存接近上限时,即使堆使用量不高,也可能因为直接内存、线程栈、元空间或其他 Native 内存导致被系统 OOM Kill。

1.2 常见异常及初步判断

  • java.lang.OutOfMemoryError: Java heap space:堆空间不足。可能是堆设置过小,也可能是对象创建过快、对象被长期引用或发生内存泄漏。

  • java.lang.OutOfMemoryError: GC overhead limit exceeded:GC 花费大量时间但回收效果很小,通常需要检查堆中对象是否持续存活、是否存在大量短时间分配或堆容量不合理。

  • java.lang.OutOfMemoryError: Metaspace:元空间不足,重点检查动态生成类、类加载器未释放、热部署或元空间上限设置。

  • java.lang.OutOfMemoryError: Direct buffer memory:直接内存不足,检查 NIO/Netty Buffer 的使用、释放和 MaxDirectMemorySize 配置。

  • java.lang.OutOfMemoryError: unable to create native thread:无法创建更多本地线程,检查线程数量、线程栈大小、进程/容器 PID 限制和系统资源。

  • java.lang.StackOverflowError:通常是递归过深或递归没有正确终止,也可能是线程栈设置较小。

  • 容器发生 OOM Kill,但 Java 没有打印 OutOfMemoryError:可能是操作系统或容器平台直接终止进程,需要查看容器事件、内核日志和 cgroup 内存指标。

2. 线上排查常用工具

2.1 操作系统层面

bash 复制代码
 查看 CPU、内存、Load、进程概况
 top

# 查看指定 Java 进程的线程级 CPU 使用情况
 top -Hp <PID>

# 查看进程线程数
 ps -o nlwp= -p <PID>

# 查看进程启动参数、运行时间等
 ps -ef | grep java

# 查看内存概况
 free -h

# 查看磁盘空间与 inode
 df -h
df -i

# 查看进程打开文件数(需关注系统权限与输出量)
 lsof -p <PID> | wc -l

容器环境中还要检查容器内存限制、CPU quota、PID limit,以及容器重启次数和 OOM 事件。宿主机看到的资源总量不一定等于容器可用资源。

2.2 JDK 自带工具

bash 复制代码
# 查看 JVM 进程
jps -lv

# 查看 GC 各区使用情况(每秒采样一次,共 10 次)
jstat -gcutil <PID> 1000 10

# 查看堆摘要(较新 JDK 通常支持)
jcmd <PID> GC.heap_info

# 查看 JVM 参数
jcmd <PID> VM.flags
jcmd <PID> VM.command_line

# 导出线程栈
jstack -l <PID> > thread-1.txt

# 查看类实例数量统计(可能有一定开销)
jcmd <PID> GC.class_histogram

# 导出堆 Dump;文件可能很大,也可能带来明显停顿
jmap -dump:format=b,file=/tmp/heap.hprof <PID>

补充说明:

  • jstat -gcutil 常见字段包括 S0、S1、E、O、M、CCS、YGC、YGCT、FGC、FGCT、GCT。重点关注老年代占用趋势、Young GC/Full GC 次数及耗时变化。

  • 不同 JDK 版本对 jcmd、jmap 参数的支持有所差异,执行前可以用 jcmd <PID> help 或对应命令的 -h 查看。

  • Attach 工具需要具备相应权限,并且目标 JVM 需要允许 Attach。容器中还需保证工具与目标 JVM 位于可访问的进程命名空间。

  • Heap Dump 可能占用大量磁盘空间,并对业务线程造成暂停或额外负载。生产操作前应确认磁盘空间、影响窗口和文件保存位置。

2.3 Arthas 常用命令

Arthas 适合在线诊断 Java 进程,可以在不重启服务的情况下查看线程、类、方法调用和部分运行指标。但动态追踪命令可能增加 CPU 开销,不应长时间、大范围使用。

命令 常见用途
dashboard 查看 JVM、线程、内存、GC 等整体运行信息
thread 查看线程状态、线程栈;thread -n 5 查看 CPU 占用较高的线程
thread <id> 查看指定线程栈
jvm 查看 JVM 信息
heapdump 导出 Heap Dump
sc 搜索已加载的类
sm 查看类的方法信息
jad 反编译已加载类,辅助确认线上实际运行代码
watch 观察方法入参、返回值和异常等
trace 跟踪方法内部调用耗时
stack 查看方法调用路径
monitor 统计方法调用次数、耗时、成功/失败等
profiler 采样分析 CPU 等性能热点(需结合版本与环境)

示例:

bash 复制代码
# 查找 CPU 占用较高的线程
thread -n 5

# 查看某个线程的调用栈
thread 123

# 观察方法调用参数与返回结果(示例表达式需按实际类名调整)
watch com.example.service.OrderService createOrder '{params,returnObj,throwExp}' -x 2

# 跟踪方法调用耗时
trace com.example.service.OrderService createOrder

# 查看线上加载的类
sc -d com.example.service.OrderService

使用建议:先确定目标类和方法,再缩小追踪范围;对高 QPS 接口谨慎使用 watch、trace、monitor,避免通配整个应用或长时间采集。

3. CPU 使用率过高

3.1 常见原因

  1. 业务代码出现死循环、大量重复计算或复杂度过高的算法。

  2. 大量线程同时运行,线程池配置不合理或出现任务堆积后的集中执行。

  3. GC 线程占用 CPU 较高,例如分配速率过高或堆内存压力大。

  4. 正则表达式回溯、序列化/反序列化、加解密、压缩等操作消耗较多 CPU。

  5. 流量突增、热点接口或异常请求导致 CPU 被打满。

  6. 容器 CPU 配额过低,导致节流和接口耗时增加;这不一定表现为宿主机 CPU 使用率很高。

3.2 排查步骤

第一步:确认是机器、进程还是线程的问题。

复制代码
 
bash 复制代码
# 查看整机与进程 CPU 情况
 top
 ​
 # 查看 Java 进程内部线程 CPU 情况
 top -Hp <PID>

第二步:找出高 CPU 线程,并把线程 ID 转成十六进制。

bash 复制代码
 # 将十进制线程 ID 转为十六进制
 printf '%x\n' <线程ID>

第三步:在线程栈中按 nid 查找。

复制代码
 
bash 复制代码
jstack -l <PID> > /tmp/thread.txt
 grep -n -A 30 -B 5 'nid=0x<十六进制线程ID>' /tmp/thread.txt

nid 是操作系统线程 ID,通常可以与 top -Hp 看到的线程 ID 对应。找到线程栈后,结合线程名称、状态和业务代码判断:

  • RUNNABLE 且持续执行同一段代码:可能存在死循环、计算热点或频繁重试。

  • 大量 GC 线程活跃:继续看 GC 日志、分配速率和堆使用趋势。

  • 大量业务线程都在执行同一个热点方法:检查流量、缓存命中率和算法复杂度。

  • 线程栈停留在 Native 方法:进一步检查 JNI、网络库或系统调用。

第四步:用采样工具确认热点。

在允许的情况下,使用 Arthas profiler 或 async-profiler 采样生成火焰图,定位 CPU 时间主要消耗在哪些方法上。采样结果用于缩小范围,最终还要结合代码、请求量和指标确认原因。

3.3 处理思路

  • 修复死循环、重复计算和低效算法;避免在循环中重复执行远程调用或大对象转换。

  • 对热点数据增加合理缓存,减少重复计算,但同步考虑缓存一致性和失效策略。

  • 控制并发和流量,检查线程池的核心线程数、最大线程数、队列容量和拒绝策略。

  • 如果是 GC 导致 CPU 高,不能简单地只增加堆内存,需要分析对象分配速率、存活对象和 GC 日志。

  • 如果是容器 CPU throttling,结合容器配额和实际负载评估资源配置,不要只看宿主机 CPU。

4. 内存持续增长与内存溢出

4.1 先区分堆内存与进程内存

  • 堆内存持续上涨:优先检查对象创建、引用链、集合缓存、队列和 ThreadLocal。

  • 堆内存稳定但进程 RSS 持续上涨:检查直接内存、线程数量、元空间、JNI、Native 库和内存映射文件。

  • 容器内存突然达到上限:结合容器监控、OOM 事件和 JVM 日志,判断是 Java 主动抛出 OOM 还是被系统直接 Kill。

4.2 Heap Dump 分析流程

  1. 先确认是否可以安全导出,检查磁盘空间、文件系统和业务影响。

  2. 使用 jmap 或 jcmd 导出 Heap Dump。

  3. 使用 Eclipse MAT 等工具打开文件。

  4. 先看 Histogram,找出实例数量或 Shallow Heap 明显异常的类。

  5. 看 Dominator Tree,分析哪些对象持有大量 Retained Heap。

  6. 查看 Path to GC Roots,追踪对象为什么仍然可达。

  7. 结合业务代码确认引用是否符合预期,修复后通过压测或线上指标验证。

常见分析概念:

  • Shallow Heap:对象自身占用的内存,不包含它引用的其他对象。

  • Retained Heap:如果某个对象被回收,理论上可以随之释放的对象所占内存,用于识别关键持有者。

  • GC Roots:判断对象是否存活的引用起点,例如线程栈局部变量、静态字段、JNI 引用等。

  • Dominator:支配关系用于分析对象保留的内存规模,帮助找到大量对象共同依赖的持有者。

4.3 常见内存泄漏场景

静态集合持续增长

将对象放入 static Map、static List 或全局缓存,但没有过期和清理机制,导致对象长期被引用。解决时应增加容量限制、过期淘汰和必要的清理逻辑。

缓存无上限

本地缓存没有最大容量或 TTL,数据量随着请求不断增长。应明确缓存容量、淘汰策略、过期策略和异常时的降级方案。

ThreadLocal 未清理

线程池中的线程会被复用,如果任务执行后未清理 ThreadLocal,值可能长期挂在线程上。建议在 finally 中调用 remove():

java 复制代码
private static final ThreadLocal<String> CONTEXT = new ThreadLocal<>();

public void process() {
    try {
        CONTEXT.set("trace-context");
        // 业务处理
    } finally {
        CONTEXT.remove();
    }
}

监听器、回调或定时任务未注销

对象已经不再使用,但仍被事件监听器、回调列表或任务调度器引用。应在生命周期结束时注销。

大对象或大集合被意外保留

例如一次性查询加载大量数据、批量导出将全部结果放入内存、日志上下文保存大对象。应采用分页、流式处理、批次处理和合理的结果集大小限制。

类加载器泄漏

应用热部署、动态生成类、脚本引擎或线程上下文类加载器未释放,可能导致类元数据无法卸载,进而引起元空间持续增长。

4.4 内存问题处理建议

  • 不要只因为发生 OOM 就直接调大 -Xmx;先确认对象是否应该存活。

  • 检查堆 Dump 中的大对象、集合、缓存和引用链。

  • 检查对象分配速率以及 GC 后老年代是否持续上涨。

  • 对导出、报表、批处理和大查询增加分页、分批和流式处理。

  • 对缓存增加容量和过期控制;对线程变量、监听器和资源增加生命周期管理。

  • 堆参数调整需要结合容器内存预算,给线程栈、直接内存、元空间和其他 Native 内存留出空间。

5. 频繁 Full GC 与 GC 停顿过长

5.1 可能原因

  1. 老年代空间不足,晋升对象过多。

  2. 大对象或超大数组频繁分配,导致老年代压力增加。

  3. 大量对象被缓存、静态集合或业务线程持有,GC 后仍然存活。

  4. 堆设置过小,无法容纳实际存活对象和业务峰值。

  5. 元空间达到上限,触发相关 GC 或类卸载压力。

  6. GC 参数与堆规模、业务分配模式不匹配。

  7. 在 G1 等收集器下,Mixed GC 回收效果不理想,或并发标记跟不上对象分配速度。

5.2 排查步骤

先观察 GC 指标。

bash 复制代码
jstat -gcutil <PID> 1000 10

重点关注:

  • O:老年代使用率是否持续上涨,GC 后是否能够下降。

  • YGC / YGCT:Young GC 次数及总耗时是否明显增长。

  • FGC / FGCT:Full GC 次数和总耗时是否异常。

  • M:元空间使用率是否持续增长。

单次采样不能直接说明问题,需要连续观察趋势,并结合 GC 日志中的具体原因、停顿时间和回收前后占用。

再分析 GC 日志。

关注 GC 类型、触发原因、回收前后堆占用、暂停时间、并发阶段耗时和是否存在连续 Full GC。

最后结合堆 Dump 和业务流量。

如果 Full GC 后老年代占用仍然很高,优先检查存活对象和引用链;如果 Full GC 后明显下降但很快又升高,检查对象分配速度、大查询、批处理或流量变化。

5.3 处理思路

  • 修复不合理的对象长期持有和无界缓存。

  • 减少高峰期一次性创建大量对象;批量任务拆分处理。

  • 检查大对象、数组和集合的创建,评估是否可以复用或流式处理。

  • 结合实际存活集、峰值流量和容器资源调整堆大小。

  • 对 G1 等收集器,先分析日志和目标停顿时间,不要在没有证据时频繁修改 MaxGCPauseMillis、Region 等参数。

  • 变更 GC 参数后必须经过压测和灰度观察,并保留回滚方案。

5.4 G1 收集器需要掌握的重点

G1 将堆划分为多个 Region,优先回收收益较高的区域,并通过并发标记识别老年代存活情况。常见阶段包括 Young GC、并发标记、Mixed GC 和必要时的 Full GC。

排查时关注:

  • Young GC 是否过于频繁,是否与对象分配速率有关。

  • 并发标记是否能及时完成。

  • Mixed GC 是否能够有效回收老年代 Region。

  • 是否出现 Humongous 对象(较大的对象可能占用连续 Region),以及相关分配压力。

  • 是否出现 Full GC,查看日志中具体触发原因。

不要把"使用 G1"理解为不会发生 Full GC。任何收集器都需要结合对象分配模式、堆大小和业务负载分析。

6. 线程阻塞、线程数过多与死锁

6.1 常见线程状态

  • RUNNABLE:正在运行或等待操作系统资源,不一定代表 CPU 一直在执行。

  • BLOCKED:等待进入某个 synchronized 监视器锁。

  • WAITING:无限期等待其他线程执行特定动作,例如 Object.wait()、LockSupport.park()。

  • TIMED_WAITING:限时等待,例如 Thread.sleep()、带超时的等待。

6.2 线程数过多

可能原因:

  • 线程池没有上限或最大线程数配置过大。

  • 为每个请求创建独立线程,缺少统一线程池管理。

  • 线程阻塞在慢 SQL、远程调用或锁等待,导致业务不断创建新线程。

  • 线程池任务堆积,线程无法及时退出。

  • 容器 PID 限制、系统线程限制或线程栈内存不足。

排查:

bash 复制代码
# 查看 Java 进程线程数量
ps -o nlwp= -p <PID>

# 统计线程栈中的线程状态(不同 JDK/输出格式可能略有差异)
jstack <PID> > /tmp/thread.txt

grep -c 'java.lang.Thread.State' /tmp/thread.txt

查看线程池的活跃线程数、队列长度、任务完成数、拒绝数和执行耗时。线程池需要有界队列和明确的拒绝策略,不能通过无限增加线程数掩盖下游变慢的问题。

6.3 死锁定位

复制代码
 jstack -l <PID> > /tmp/thread.txt

搜索 Found one Java-level deadlock。如果存在死锁,线程栈通常会列出相互等待的线程及持有的锁。

常见成因:

  • 多个线程以不同顺序获取多把锁。

  • 锁粒度过大,锁内执行远程调用或长时间业务操作。

  • synchronized 与显式锁混用时缺少统一的加锁顺序。

解决思路:

  • 统一多个锁的获取顺序。

  • 缩小临界区,避免锁内执行耗时 I/O。

  • 尽可能使用带超时的锁获取方式。

  • 对锁使用情况增加监控,必要时设计无锁或分段处理方案。

6.4 线程池排查要点

线程池的核心参数包括核心线程数、最大线程数、空闲线程存活时间、任务队列和拒绝策略。排查时不能只看线程数量,还需要看任务等待时间和执行耗时。

  • CPU 密集型任务:重点评估 CPU 核数、上下文切换和任务计算量。

  • IO 密集型任务:需要考虑等待时间,但不能无限扩大线程数;还要受数据库连接池、下游并发能力和容器资源限制。

  • 队列持续增长:说明任务提交速度超过处理速度,需要检查流量、任务耗时和下游依赖。

  • 拒绝任务:需要明确业务是否允许丢弃、降级、同步执行或返回可重试错误。

7. 直接内存、元空间与类加载问题

7.1 直接内存问题

NIO、Netty 等组件可能使用堆外直接内存。直接内存不属于 Java 堆,但会占用进程/容器内存。

排查方向:

  • 堆内存不高但 RSS 很高时,检查直接内存和 Native 内存。

  • 检查 ByteBuffer/Netty ByteBuf 的生命周期和引用计数释放。

  • 检查是否存在缓存池使用不当、对象泄漏或堆外缓冲区长期持有。

  • 检查 -XX:MaxDirectMemorySize,但不要仅靠增大上限解决泄漏。

7.2 元空间问题

元空间存放类元数据,使用本地内存。常见原因包括动态生成类过多、类加载器泄漏、热部署后旧类加载器无法回收。

排查方向:

  • 查看元空间使用趋势和已加载类数量。

  • 结合类加载器统计或 Arthas sc -d 等信息排查重复加载。

  • 检查动态代理、CGLIB、脚本引擎、热部署、插件机制等场景。

  • 检查线程上下文类加载器、静态引用和线程池线程是否持有旧类加载器。

8. JVM 参数与 GC 日志

8.1 常见 JVM 参数

bash 复制代码
-Xms<size>                   # 初始堆大小
-Xmx<size>                   # 最大堆大小
-Xss<size>                   # 每个线程的栈大小
-XX:MetaspaceSize=<size>     # 元空间初始高水位相关阈值
-XX:MaxMetaspaceSize=<size>  # 元空间最大容量
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/path/heap.hprof

说明:MetaspaceSize 不等同于元空间最大容量;它是触发元空间相关 GC 的初始高水位阈值之一。不同 JDK 版本和收集器的参数行为可能不同。

8.2 JDK 8 常见 GC 日志参数

bash 复制代码
-XX:+PrintGCDetails
-XX:+PrintGCDateStamps
-Xloggc:/path/gc.log
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/path/heap.hprof

8.3 JDK 9 及以上统一日志示例

bash 复制代码
-Xlog:gc*:file=/path/gc.log:time,uptime,level,tags
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/path/heap.hprof

GC 日志建议配置滚动和保留策略,避免日志文件无限增长。生产环境需要确认日志目录空间、权限和采集方式。

8.4 参数调整原则

  • 先分析,再调整;没有 GC 日志和内存数据,不建议盲目修改。

  • -Xms 与 -Xmx 是否设置为相同值,要结合容器资源和部署策略决定,并非所有场景都必须相同。

  • 堆大小不能占满容器内存,还需为线程栈、直接内存、元空间、Code Cache 和其他 Native 内存预留空间。

  • 调整线程栈大小可能影响可创建线程数,也可能导致深层调用栈溢出,需要验证。

  • 参数变更要经过压测、灰度和监控观察,不要同时改动多个关键参数,否则难以判断效果。

9. JVM 线上故障排查案例模板

下面是常见场景的分析模板,实际复盘时应替换成真实监控、日志和数据,不要把示例描述写成自己已经经历过的事实。

案例一:接口响应变慢,同时 Full GC 频繁

现象:接口响应时间上升,实例 CPU 或 GC 暂停时间增加,Full GC 次数明显增多。

排查:

  1. 对比异常时间点的请求量、接口耗时、错误率和实例资源。

  2. 使用 jstat -gcutil 观察老年代与 Full GC 次数变化。

  3. 分析 GC 日志,判断回收前后堆占用及触发原因。

  4. 必要时采集 Heap Dump,使用 MAT 查看大对象、集合和引用链。

  5. 对照业务代码检查大查询、批量导出、无界缓存或对象长期持有。

处理:根据证据修复对象滞留或大批量分配问题;需要时优化分页/流式处理,并在容量评估后调整堆参数。

验证:观察 Full GC 频率、GC 后老年代占用、接口 P95/P99 和实例内存是否恢复稳定。

案例二:Java 进程 CPU 突然升高

现象:实例 CPU 使用率持续较高,接口耗时增加。

排查:

  1. 用 top 确认高 CPU 进程。

  2. 用 top -Hp <PID> 找到高 CPU 线程。

  3. 将线程 ID 转十六进制,通过 jstack 的 nid 找到线程栈。

  4. 用 Arthas 或采样分析工具确认热点方法。

  5. 结合请求量、日志和代码确认是否为死循环、热点计算、重试或 GC。

处理:修复热点代码,控制并发或流量;若为 GC 或下游超时引起的连锁问题,继续处理上游根因。

案例三:容器内存达到上限,但堆使用率不高

现象:容器内存接近限制,服务被 OOM Kill 或频繁重启,但 Java 堆使用量并不高。

排查:检查容器 RSS、线程数、直接内存、元空间和 Native 内存;结合线程栈、NIO/Netty Buffer 使用情况及容器 OOM 事件确认。

处理:修复堆外内存或线程资源泄漏,合理分配堆与容器内存,并增加容器内存、线程数和重启次数监控。

复制代码
相关推荐
钱栈up20 小时前
IDEA 一天冻死两次:顺着线程 dump 揪出 JRebel,再用 DCEVM 把它替掉
jvm·agent·intellij idea
薛之谦_2 天前
Java 全栈知识体系:从 IDEA 高效开发到 JVM、并发与 Stream 实战
java·jvm·intellij-idea
jyOverQ2 天前
从零学 JVM(六):垃圾回收算法详解——标记清除、标记复制与标记整理
jvm·算法
金銀銅鐵2 天前
带您看懂字节码指令(三):一行加法里有什么
java·jvm
jyOverQ2 天前
从零学 JVM(七):垃圾收集器详解——Serial、ParNew、Parallel、CMS 与 G1
java·jvm
金銀銅鐵3 天前
带您看懂字节码指令(三):同一行加法,为什么有四种指令
java·jvm
jyOverQ3 天前
从零学 JVM(五):垃圾回收机制——对象存活判断与 GC Roots
jvm
金銀銅鐵3 天前
一个 4 个常量的枚举,Kotlin 在字节码里生成了什么
jvm·kotlin
2301_808414383 天前
Linux线程的同步与互斥
jvm