jvm未命名线程一直waiting问题排查

2023-11-05 06:50
文章标签 java 问题 jvm 线程 waiting 排查 未命名

本文主要是介绍jvm未命名线程一直waiting问题排查，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

机器情况

启动参数 : -Xms4700m -Xmx4700m

简单监控图

jstack 分析

fastthread.io 分析

有较多未命名的线程. 但项目中搜了使用线程的地方都加了命名

OOM KILLER 日志

grep "Out of memory" /var/log/messages

ps -A -ostat,ppid,pid,cmd | grep -e '^[Zz]' 查看僵尸进程 -> 无

arthas -> vmtool --action forceGc 强制full gc, 并不能减少进程的内存占用

目前线上未开启 VM.native_memory

初步诊断

应用存在大量的 ThreadPoolExecutor 以及派生类对象生成，可能的情

  1. 预初始化（启动）核心（core）线程（数量：1），并且没有任务来执行
  2. 已经执行过一次任务，再也没有新任务执行
    1. 可能造成的原因：
      1. ThreadPoolExecutor 由于某种缓存机制失效，导致了 computeIfAbsent
        1. ThreadPoolExecutor 没有合理 Shutdown，比如在方法内部创建 ThreadPoolExecutor，示例代码如下：

public void sum() {ThreadPoolExecutor executor  = Executors.newFixedThreadPool(1);for(int i=0;i<10;i++){executor.submit(...);}// core thread 一直在执行，不过没有任务罢了，当下 Keep-Live = 0 ，永久等待// core thread Thread.State == Thread.State.WAITING// core thread 是否是 ThreadPoolExecutor 成员// ThreadPoolExecutor -> workers(HashSet<Worker>) -> Worker -> Thread// executor.shutdown();
}

后续观测现象

每30分钟有一段线程凸起, 并且大致看下来有残留 , 可能就是上文创建过多单个线程池的原因?

看了下30分钟定时任务 , 执行的任务列表

1 有部分临时线程池没有shutdown

定时任务里确实 存在部分临时创建的线程池没有shutdown, 导致一直waiting

2 client 没单例

定时任务里 发现其中有的定时任务使用 okHttpClient , 但根据经验来看, 每个请求创建一个client存在一定问题

但不是原因 , 发布后 waiting线程数依旧很多

3 机器是双核导致部分问题

发现有 completeableFuture 没有使用自定义线程池, 同时机器是2核8G 实质并没有用到 默认commonPool

内部使用completeableFuture的方法会导致没有复用pool , 每次创建了新线程

真正原因
排查方法

持续监控未命名线程池的活动, 保存runnable时候的堆栈, 在waiting较久时打印出来

 /*** 2秒打一次*/@SneakyThrows@Scheduled(cron = "0/2 * * * * ?")public void localMetricPrintSchedule() {jvmObserve();}private static Map<Long, ThreadInfoStore> runStatsMap = new WeakHashMap<>();@Datapublic static class ThreadInfoStore {private Long threadId;private String threadName;private List<String> runPrintStackTraces = Lists.newArrayList();private int waitingCheckCount = 0;public boolean printEnabled() {return this.waitingCheckCount == 100;}String formatTraceToString(StackTraceElement[] stackTrace) {StringBuilder sb = new StringBuilder();for (int i = 0; i < stackTrace.length; i++) {StackTraceElement element = stackTrace[i];sb.append(element.toString()).append("\n");}return sb.toString();}public void pushPrintStackTrace(StackTraceElement[] stackTrace) {if (stackTrace.length == 0) {return;}if (runPrintStackTraces == null) {runPrintStackTraces = new ArrayList<>();}//保存3次run堆栈, 超过3次, 将最后一次作为第三次if (runPrintStackTraces.size() == 0 || runPrintStackTraces.size() == 1 || runPrintStackTraces.size() == 2) {runPrintStackTraces.add(formatTraceToString(stackTrace));} else {runPrintStackTraces.remove(runPrintStackTraces.size() - 1);runPrintStackTraces.add(formatTraceToString(stackTrace));}}}/*** 当线程从 run -> waiting  并且一直waiting的时候, 打印出堆栈** 注意点 :* 针对的是 未命名线程* 临时的线程要过滤, 防止内存泄露*/public static void jvmObserve() {ThreadMXBean tmx = ManagementFactory.getThreadMXBean();long[] allThreadIds = tmx.getAllThreadIds();ThreadInfo[] allThreadInfo = tmx.getThreadInfo(allThreadIds);List<ThreadInfo> noNameThreadInfoList = Lists.newArrayList();for (ThreadInfo threadInfo : allThreadInfo) {String threadName = threadInfo.getThreadName();//针对目前发现的多pool 单core线程池过多过滤if (threadName.startsWith("pool-")&& threadName.endsWith("-1")) {noNameThreadInfoList.add(threadInfo);}}//当线程从 run -> waiting  并且一直waiting的时候, 打印出堆栈for (ThreadInfo threadInfo : noNameThreadInfoList) {threadInfo = tmx.getThreadInfo(threadInfo.getThreadId(), 10);long threadId = threadInfo.getThreadId();String threadName = threadInfo.getThreadName();ThreadInfoStore threadInfoStore = new ThreadInfoStore();threadInfoStore.setThreadId(threadId);threadInfoStore.setThreadName(threadName);if (threadInfo.getThreadState() == Thread.State.RUNNABLE) {//只记录runnable的几次堆栈ThreadInfoStore runThreadInfoStore = runStatsMap.get(threadId);if (null == runThreadInfoStore) {threadInfoStore.pushPrintStackTrace(threadInfo.getStackTrace());runStatsMap.put(threadId, threadInfoStore);} else {runThreadInfoStore.pushPrintStackTrace(threadInfo.getStackTrace());runThreadInfoStore.setWaitingCheckCount(0);}} else if (threadInfo.getThreadState() == Thread.State.WAITING) {ThreadInfoStore runThreadInfoStore = runStatsMap.get(threadId);if (runThreadInfoStore == null) {continue;}runThreadInfoStore.waitingCheckCount++;//清除感觉已经死了的线程 , 105次判断if (runThreadInfoStore.waitingCheckCount > 105) {runStatsMap.remove(threadId);}}}//清理不存在的线程Set<Long> existThreadIds = noNameThreadInfoList.stream().map(ThreadInfo::getThreadId).collect(Collectors.toSet());for (Long threadId : runStatsMap.keySet()) {if (!existThreadIds.contains(threadId)) {runStatsMap.remove(threadId);}}if (noPrintEnableThreads(runStatsMap)) {return;}//打印一下 waiting次数达到100次的线程run堆栈StringBuilder stringBuilder = new StringBuilder();stringBuilder.append("jvm waiting线程观测").append("\n").append("allThreadIds: ").append(allThreadIds.length).append("\n").append("noNameThreadCount: ").append(noNameThreadInfoList.size()).append("\n");for (Map.Entry<Long, ThreadInfoStore> entry : runStatsMap.entrySet()) {if (entry.getValue().printEnabled()) {stringBuilder.append("====较久waiting线程堆栈打印====").append("\n");stringBuilder.append("waiting线程name: ").append(entry.getValue().getThreadName()).append("\n");List<String> runPrintStackTraces = entry.getValue().getRunPrintStackTraces();for (int i = 0; i < runPrintStackTraces.size(); i++) {String stackTrace = runPrintStackTraces.get(i);stringBuilder.append(">>>> waiting线程runStackTrace[").append(i).append("]: ").append("\n").append(stackTrace).append("\n");}}}BizLogUtil.info(log, stringBuilder.toString());}private static boolean noPrintEnableThreads(Map<Long, ThreadInfoStore> runStatsMap) {if (runStatsMap.isEmpty()) {return true;}for (Map.Entry<Long, ThreadInfoStore> entry : runStatsMap.entrySet()) {if (entry.getValue().printEnabled()) {return false;}}return true;}

观察现象
jvm waiting线程观测
allThreadIds: 1118
noNameThreadCount: 517
====较久waiting线程堆栈打印====
waiting线程name: pool-572-thread-1
>>>> waiting线程runStackTrace[0]: 
java.net.PlainSocketImpl.socketConnect(Native Method)
java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:476)
java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:218)
java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:200)
java.net.SocksSocketImpl.connect(SocksSocketImpl.java:394)
java.net.Socket.connect(Socket.java:606)
org.apache.http.conn.ssl.SSLConnectionSocketFactory.connectSocket(SSLConnectionSocketFactory.java:368)
com.amazonaws.http.conn.ssl.SdkTLSSocketFactory.connectSocket(SdkTLSSocketFactory.java:142)
org.apache.http.impl.conn.DefaultHttpClientConnectionOperator.connect(DefaultHttpClientConnectionOperator.java:142)
org.apache.http.impl.conn.PoolingHttpClientConnectionManager.connect(PoolingHttpClientConnectionManager.java:376)
sun.reflect.GeneratedMethodAccessor549.invoke(Unknown Source)
sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
java.lang.reflect.Method.invoke(Method.java:498)
com.amazonaws.http.conn.ClientConnectionManagerFactory$Handler.invoke(ClientConnectionManagerFactory.java:76)
com.amazonaws.http.conn.$Proxy494.connect(Unknown Source)
org.apache.http.impl.execchain.MainClientExec.establishRoute(MainClientExec.java:393)
org.apache.http.impl.execchain.MainClientExec.execute(MainClientExec.java:236)
org.apache.http.impl.execchain.ProtocolExec.execute(ProtocolExec.java:186)
org.apache.http.impl.client.InternalHttpClient.doExecute(InternalHttpClient.java:185)
org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:83)
org.apache.http.impl.client.CloseableHttpClient.execute(CloseableHttpClient.java:56)
com.amazonaws.http.apache.client.impl.SdkHttpClient.execute(SdkHttpClient.java:72)
com.amazonaws.http.AmazonHttpClient$RequestExecutor.executeOneRequest(AmazonHttpClient.java:1330)
com.amazonaws.http.AmazonHttpClient$RequestExecutor.executeHelper(AmazonHttpClient.java:1145)
com.amazonaws.http.AmazonHttpClient$RequestExecutor.doExecute(AmazonHttpClient.java:802)
com.amazonaws.http.AmazonHttpClient$RequestExecutor.executeWithTimer(AmazonHttpClient.java:770)
com.amazonaws.http.AmazonHttpClient$RequestExecutor.execute(AmazonHttpClient.java:744)
com.amazonaws.http.AmazonHttpClient$RequestExecutor.access$500(AmazonHttpClient.java:704)
com.amazonaws.http.AmazonHttpClient$RequestExecutionBuilderImpl.execute(AmazonHttpClient.java:686)
com.amazonaws.http.AmazonHttpClient.execute(AmazonHttpClient.java:550)
com.amazonaws.http.AmazonHttpClient.execute(AmazonHttpClient.java:530)
com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClient.doInvoke(AWSSecurityTokenServiceClient.java:1719)
com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClient.invoke(AWSSecurityTokenServiceClient.java:1686)
com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClient.invoke(AWSSecurityTokenServiceClient.java:1675)
com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClient.executeAssumeRole(AWSSecurityTokenServiceClient.java:589)
com.amazonaws.services.securitytoken.AWSSecurityTokenServiceClient.assumeRole(AWSSecurityTokenServiceClient.java:561)
com.amazonaws.auth.STSAssumeRoleSessionCredentialsProvider.newSession(STSAssumeRoleSessionCredentialsProvider.java:321)
com.amazonaws.auth.STSAssumeRoleSessionCredentialsProvider.access$000(STSAssumeRoleSessionCredentialsProvider.java:37)
com.amazonaws.auth.STSAssumeRoleSessionCredentialsProvider$1.call(STSAssumeRoleSessionCredentialsProvider.java:76)
com.amazonaws.auth.STSAssumeRoleSessionCredentialsProvider$1.call(STSAssumeRoleSessionCredentialsProvider.java:73)
com.amazonaws.auth.RefreshableTask.refreshValue(RefreshableTask.java:257)
com.amazonaws.auth.RefreshableTask.access$100(RefreshableTask.java:41)
com.amazonaws.auth.RefreshableTask$1.run(RefreshableTask.java:238)
java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
java.util.concurrent.FutureTask.run(FutureTask.java:266)
java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1149)
java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
java.lang.Thread.run(Thread.java:750)

发现是引的三方包 亚马逊的http client 导致..

应用中创建了多个client , 但是每个client 都会维护一个检测连接相关东西的task , 并且是直接使用executors new出来的未命名线程 ,  最终重写class  定义了一个全局唯一的线程池解决

类似案例

JVM 线程无法回收排查 -- 实例_linux jvm未回收_Golden_Dog的博客-CSDN博客

java真实占用内存分布

操作系统对内存的分配管理典型地分为两个阶段：保留（reserve）和提交（commit）。保留阶段告知系统从某一地址开始到后面的dwSize大小的连续虚拟内存需要供程序使用，进程其他分配内存的操作不得使用这段内存；提交阶段将虚拟地址映射到对应的真实物理内存中，这样这块内存就可以正常使用[1]。

top 与 jvm实际占用内存分析

比较结果发现

实际600MB > （jvm堆内+堆外）319MB

但是有一点是可以知道的，就是这些600M 内存的确被jvm所属进程使用了。

使用 jcmd pid VM.native_memory summary

-XX:NativeMemoryTracking=summary

jcmd pid VM.native_memory summary 查看jvm 真实占用的内存分布情况

committed就是实际使用的内存

所以一个java进程的内存占用：

  1. heap:堆内存，即-Xmx限制的最大堆大小的内存。
  2. class：加载的类与方法信息，其实就是 metaSpace，包含两部分：
    1. 一是metadata，被-XX:MaxMetaspaceSize限制最大大小，
    2. 二是classSpace，被-XX:CompressedClassSpaceSize限制最大大小
  1. thread：线程与线程栈占用内存，每个线程栈占用大小受-Xss限制，但是总大小没有限制
  2. code:JIT 即时编译后（C1 C2 编译器优化）的代码占用内存，受-XX:ReservedCodeCacheSize限制
  3. gc：垃圾回收占用内存，例如垃圾回收需要的 CardTable，标记数，区域划分记录，还有标记 GC Root等等，都需要内存。这个不受限制，一般不会很大的。Parallel GC 不会占什么内存，G1 最多会占堆内存 10%左右额外内存，ZGC 会最多会占堆内存 15~20%左右额外内存，但是这些都在不断优化。（注意，不是占用堆的内存，而是大小和堆内存里面对象占用情况相关）
  4. compiler:C1 C2 编译器本身的代码和标记占用的内存，这个不受限制，一般不会很大的
  5. internal：命令行解析，JVMTI 使用的内存，这个不受限制，一般不会很大的
  6. symbol：常量池占用的大小，字符串常量池受-XX:StringTableSize个数限制，总内存大小不受限制
  7. Native Memory Tracking：内存采集本身占用的内存大小，如果没有打开采集（那就看不到这个了）
  8. Arena Chunk：所有通过 arena 方式分配的内存，这个不受限制，一般不会很大的

由下图可以看到 600M实际的占用分布 , total的 600M也基本符合

这篇关于jvm未命名线程一直waiting问题排查的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/348157。

相关文章

springboot rocketmq配置生产者和消息者的步骤

springboot rocketmq配置生产者和消息者的步骤

《springbootrocketmq配置生产者和消息者的步骤》本文介绍了如何在SpringBoot中集成RocketMQ,包括添加依赖、配置application.yml、创建生产者和消费者,并展... 目录1. 添加依赖2. 配置application.yml3. 创建生产者4. 创建消费者5. 使用在
阅读更多...
Spring Retry 实现乐观锁重试实践记录

Spring Retry 实现乐观锁重试实践记录

《SpringRetry实现乐观锁重试实践记录》本文介绍了在秒杀商品SKU表中使用乐观锁和MybatisPlus配置乐观锁的方法,并分析了测试环境和生产环境的隔离级别对乐观锁的影响,通过简单验证,... 目录一、场景分析 二、简单验证 2.1、可重复读 2.2、读已提交 三、最佳实践 3.1、配置重试模板
阅读更多...
Spring中@Lazy注解的使用技巧与实例解析

Spring中@Lazy注解的使用技巧与实例解析

《Spring中@Lazy注解的使用技巧与实例解析》@Lazy注解在Spring框架中用于延迟Bean的初始化,优化应用启动性能,它不仅适用于@Bean和@Component,还可以用于注入点,通过将... 目录一、@Lazy注解的作用（一）延迟Bean的初始化（二）与@Autowired结合使用二、实例解
阅读更多...
SpringBoot使用Jasypt对YML文件配置内容加密的方法(数据库密码加密)

SpringBoot使用Jasypt对YML文件配置内容加密的方法(数据库密码加密)

《SpringBoot使用Jasypt对YML文件配置内容加密的方法(数据库密码加密)》本文介绍了如何在SpringBoot项目中使用Jasypt对application.yml文件中的敏感信息（如数... 目录SpringBoot使用Jasypt对YML文件配置内容进行加密（例：数据库密码加密）前言一、J
阅读更多...
Java中有什么工具可以进行代码反编译详解

Java中有什么工具可以进行代码反编译详解

《Java中有什么工具可以进行代码反编译详解》：本文主要介绍Java中有什么工具可以进行代码反编译的相关资,料,包括JD-GUI、CFR、Procyon、Fernflower、Javap、Byte... 目录1.JD-GUI2.CFR3.Procyon Decompiler4.Fernflower5.Jav
阅读更多...
Spring Boot 中正确地在异步线程中使用 HttpServletRequest的方法

Spring Boot 中正确地在异步线程中使用 HttpServletRequest的方法

《SpringBoot中正确地在异步线程中使用HttpServletRequest的方法》文章讨论了在SpringBoot中如何在异步线程中正确使用HttpServletRequest的问题,... 目录前言一、问题的来源：为什么异步线程中无法访问 HttpServletRequest？1. 请求上下文与线
阅读更多...
在 Spring Boot 中使用异步线程时的 HttpServletRequest 复用问题记录

在 Spring Boot 中使用异步线程时的 HttpServletRequest 复用问题记录

《在SpringBoot中使用异步线程时的HttpServletRequest复用问题记录》文章讨论了在SpringBoot中使用异步线程时,由于HttpServletRequest复用导致... 目录一、问题描述：异步线程操作导致请求复用时 Cookie 解析失败1. 场景背景2. 问题根源二、问题详细分
阅读更多...
Java对象和JSON字符串之间的转换方法(全网最清晰)

Java对象和JSON字符串之间的转换方法(全网最清晰)

《Java对象和JSON字符串之间的转换方法(全网最清晰)》：本文主要介绍如何在Java中使用Jackson库将对象转换为JSON字符串,并提供了一个简单的工具类示例,该工具类支持基本的转换功能,... 目录前言1. 引入 Jackson 依赖2. 创建 jsON 工具类3. 使用示例转换 Java 对象为
阅读更多...
解读为什么@Autowired在属性上被警告,在setter方法上不被警告问题

解读为什么@Autowired在属性上被警告,在setter方法上不被警告问题

《解读为什么@Autowired在属性上被警告,在setter方法上不被警告问题》在Spring开发中,@Autowired注解常用于实现依赖注入,它可以应用于类的属性、构造器或setter方法上,然... 目录1. 为什么 @Autowired 在属性上被警告？1.1 隐式依赖注入1.2 IDE 的警告：
阅读更多...
SpringBoot快速接入OpenAI大模型的方法(JDK8)

SpringBoot快速接入OpenAI大模型的方法(JDK8)

《SpringBoot快速接入OpenAI大模型的方法(JDK8)》本文介绍了如何使用AI4J快速接入OpenAI大模型,并展示了如何实现流式与非流式的输出,以及对函数调用的使用,AI4J支持JDK8... 目录使用AI4J快速接入OpenAI大模型介绍AI4J-github快速使用创建SpringBoot
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2