Java线上CPU飙高与死锁排查实战:从jstack到Arthas全流程

Java线上故障排查CPU飙高死锁排查
于 2026-10-29 02:46:37 修改
·本内容遵循CC 4.0 BY-SA版权协议

1. 先从一次真实的线上事故说起:CPU 400% 意味着什么

做 Java 开发的朋友,几乎都会遇到一次这样的半夜惊醒:业务群里有人说系统卡死了,请求大面积超时。你打开监控面板,看到一台应用服务器的 CPU 使用率已经冲到 400% 甚至更高,load average 飙到几十。再一看,Java 进程还在,但 JVM 似乎已经“僵”在那里,线程池里的任务全堵着,GC 日志里 Full GC 的频率高到吓人。

这种时刻,最忌讳的就是乱猜。有人说是代码有死循环,有人说是 GC 出问题了,还有人怀疑是机器被入侵挖矿了。在我刚带团队那几年,每次遇到这种问题,第一反应也是先重启大法。但重启只能缓解,不能根治。你今天重启了,明天它还会再炸。真正要做的是拿到现场证据,把根因挖出来。这篇文章就是要把我自己在多次 CPU 飙高和死锁排查中沉淀下来的那套动作,从头到尾拆开讲清楚。适合谁看?正在背八股文找工作、想积累线上问题排查经验的 Java 开发者,以及日常工作里会碰到线上事故、需要自己定位问题的后端工程师。这里涉及的技术点不复杂,但每一步都要做到位,缺一环可能就要多折腾好几个小时。

先说一个基本常识:当一台 Linux 服务器上 CPU 使用率高企时,top 命令是最直接的入口。但 top 只能看到进程维度,也就是哪个 Java 进程在烧 CPU。要往深挖,必须配合 top -Hp、jstack、jstat、jmap 这一整套工具链。本文的核心就是:如何用这套工具链,从“CPU 飙高”这个表象,一路追到到底是哪一行代码在搞事情,并且把 Java 死锁这类并发问题的排查逻辑一并说透。


2. 从 top 到 jstack:CPU 飙高排查的标准动作

2.1 第一步永远不是看代码,而是看现场

CPU 飙高这类问题,最怕的是你等到了第二天再处理。很多现场信息是转瞬即逝的。所以在处理线上事故时,我的习惯是先开一个临时目录,把各种现场信息先 dump 下来,再做分析。别一上来就翻代码、问同事最近改了什么,那些是后面的事,先把证据固定住。

第一步,运行 top,确认哪个进程在吃 CPU:

BASH
top -c

-c 参数会展示进程的命令行,这样可以快速区分是 Java 进程、GC 进程、Kafka 进程,还是别的什么。正常情况下,你会看到类似这样的输出:

TEXT
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
23456 admin 20 0 25.6g 2.1g 16m S 380.0 5.2 124:32.32 java -Xmx2g -jar app.jar

%CPU 380.0 意味着这个 Java 进程占用了将近 4 个 CPU 内核。TIME+ 是累计 CPU 时间,如果这个值已经很大,说明问题不是刚刚发生的,而是持续一段时间了。这时候你要做的,就是把进程 PID 记下来,比如这里是 23456。

紧接着,除非你确定进程随时可能挂掉必须立刻重启,否则千万不要直接 kill。因为下一步的线程级采样,需要这个进程还活着。如果实在压力太大需要止损,那就先用 jstack -l 把线程栈 dump 下来再重启,哪怕多花几秒钟,换来的可是根因线索。

2.2 定位到具体线程:top -Hp 是承上启下的关键一步

进程确定之后,下一步必须找到进程内部的线程维度。这一步用 top -Hp:

BASH
top -Hp 23456

输出会变成线程级的,多了一个 TID(线程 ID)列:

TEXT
PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND
23458 admin 20 0 25.6g 2.1g 16m R 99.7 5.2 98:32.31 java
23459 admin 20 0 25.6g 2.1g 16m R 98.5 5.2 95:21.10 java

这里有两个线程的 CPU 使用率都在 99% 左右,说明至少有两个线程在并行地疯狂消耗 CPU。线程 ID 一般是个十进制数,但 jstack 输出里的线程 ID 是十六进制的,所以你需要做一个转换。比如 23458 转换成十六进制是 0x5ba2。

转换我一般直接用 printf:

BASH
printf "%x\n" 23458

也可以直接用 python:

BASH
python3 -c "print(hex(23458))"

这一步的重点是:拿到线程 ID 的十六进制值,然后在 jstack dump 下来的栈里,通过这个值去匹配对应的线程。如果你的 jstack 输出已经滚动过去了,或者是分批 dump 的,那么匹配的时候要找 nid=0x5ba2 这样的字段。

2.3 线程栈的采样技巧:一次 dump 不够,至少三次

很多初学者栽在这里:好不容易把 jstack 的栈 dump 下来了,但发现里面全是 WAITING、TIMED_WAITING 状态的线程,根本看不出谁在烧 CPU。原因很简单——如果只 dump 一次,高 CPU 线程正好处于某个短暂的停留点,栈里的内容可能看不出热点。正确做法是:间隔几秒连续 dump 多次,而且最好同时记录当时的 CPU 占用。

BASH
jstack -l 23456 > /tmp/jstack1.txt
sleep 5
jstack -l 23456 > /tmp/jstack2.txt
sleep 5
jstack -l 23456 > /tmp/jstack3.txt

多份栈对比,才能看出线程栈是稳定地卡在某个位置,还是在多个位置之间快速切换。如果三次都指向同一个方法,那基本就是“死循环”或“自旋等待”之类的问题;如果三次栈在变化,那可能是某个方法耗时特别长,或者是在做大量计算。

同时,配合 jstat 看一下 GC 情况:

BASH
jstat -gcutil 23456 1000 5

S0、S1、E、O 分别是幸存区、伊甸园区、老年代的使用率,YGC、FGCT 是 GC 次数和时间。如果 O 区长期爆满,FGCT 高得离谱,那 CPU 飙高的原因十有八九是 GC 频繁。这时候要解决的是内存分配和对象回收问题,而不是死循环。这份数据也是排查中必不可少的证据。


3. 线程栈不会说谎:一次 GC 抖动和一次死循环的定位实录

3.1 案例一:CPU 高但线程栈里全是图片压缩逻辑

有一回排查一个图片上传服务的 CPU 飙高问题。top -Hp 看到两个线程 CPU 接近 100%,十六进制 TID 分别是 0x3a21 和 0x3a22。连抽三份 jstack,这两条线程的栈高度一致,都卡在:

TEXT
"pool-4-thread-3" #28 prio=5 os_prio=0 tid=0x00007f41a80ce800 nid=0x3a21 runnable [0x00007f41a2ffb000]
java.lang.Thread.State: RUNNABLE
at com.sun.imageio.plugins.jpeg.JPEGImageWriter.encodeImage(Native Method)
at com.sun.imageio.plugins.jpeg.JPEGImageWriter.writeOnThread(JPEGImageWriter.java:2045)
at com.sun.imageio.plugins.jpeg.JPEGImageWriter.write(JPEGImageWriter.java:305)
at javax.imageio.ImageWriter.write(ImageWriter.java:470)
at com.example.ImageCompressor.compress(ImageCompressor.java:57)
at com.example.ImageUploadService.doUpload(ImageUploadService.java:88)
at com.example.UploadTask.call(UploadTask.java:33)

三次栈完全一致,这就不是巧合了。这段日志告诉我们:线程池中的线程正在执行 JPEG 编码,而且是本地方法 JPEGImageWriter.encodeImage。图片压缩服务烧 CPU,本身就有点敏感。我马上看了一眼堆内存,果然老年代的使用率很高,Full GC 很频繁。因为每张图片压缩完都会产生一个大 byte[],如果并发上来,这些大对象会直接进老年代,然后老年代不断被填满,触发 Full GC。

解决思路就比较清晰了:一方面压缩完的 byte[] 尽可能复用,不要把整个图片字节数组长期滞留内存;另一方面给图片压缩线程池设置合理的队列长度和拒绝策略。后来我们把压缩逻辑改成流式处理,不落全量 byte[],GC 压力小了很多,CPU 自然也掉下来了。

这个案例的教训是:CPU 飙高未必是死循环,也可能是 GC 抖动。而判断是 GC 还是死循环,不能只靠猜,要 jstack 和 jstat 一起看。这里线程栈里是 RUNNABLE 状态,而且本地方法栈卡在图片编码上,说明这些线程确实在做计算密集的工作,不是靠 GC 线程在消耗 CPU。

3.2 案例二:一段看似无害的字符串拼接,把 CPU 吃满了

再讲一个更“隐蔽”的情形。某个内部数据处理服务,每隔一段时间 CPU 就会拉满,而且没有任何异常日志。jstack 看的时候,高 CPU 线程停在:

TEXT
"main" #1 prio=5 os_prio=0 tid=0x00007f8b1c00d000 nid=0x2b78 runnable [0x00007f8b1bfd9000]
java.lang.Thread.State: RUNNABLE
at java.lang.StringBuilder.append(StringBuilder.java:136)
at com.example.DataExporter.formatData(DataExporter.java:102)
at com.example.DataExporter.export(DataExporter.java:67)

乍一看,StringBuilder.append 怎么可能会把 CPU 吃满?实际上,这里的问题不是 append 本身,而是它所在的循环。看源码后发现,formatData 里有个 while (iterator.hasNext()) 循环,对几十万条数据做格式化拼接。每次循环都 new StringBuilder(),并且拼接的字段里有一个频繁触发的 String.format,开销不小;再加上循环体里还有正则表达式匹配,正则引擎在某些输入下会进入灾难性回溯,CPU 占用就爆炸了。

这种问题光看线程栈有时候不太够,因为线程栈只显示出栈顶的方法。我的习惯是看 jstack 里那一整条栈,多抽几次,看栈里的帧是否都在同一段代码里反复出现。如果栈顶变了但栈底不变,基本可以确定是在某个循环里反复执行同一批逻辑。然后把源码拉出来,重点看循环体内有没有明显的计算密集操作,比如正则、序列化、加解密、大量字符串操作等。

顺带说一句,正则灾难性回溯是个非常经典的 CPU 杀手。它的原理是正则引擎在某些模式上会做大量回溯尝试,导致时间复杂度从 O(n) 恶化到 O(2^n)。如果你发现线程栈里出现 java.util.regex.Matcher 相关的方法,优先级非常高,一定要尽快把正则表达式换掉或者做成预编译模式,同时构造一只能够覆盖最长可能输入的超时机制。

3.3 用 Arthas 做动态排查:线上无源码时的救命工具

线上环境经常没有源码,或者不方便重启,这时候我强烈推荐用 Arthas。它是一个 Java 诊断工具,可以直接 attach 到目标 JVM 上,不需要改代码、不需要重启。在 CPU 飙高场景下,Arthas 有一个命令非常有用:thread -n 3,它会直接列出 CPU 占用最高的前 3 个线程,并打印出它们的线程栈,省去手动转换 TID 的过程:

BASH
thread -n 3

输出里会直接给出线程 ID、线程名、CPU 使用率以及堆栈信息,一眼就能看到热点。如果怀疑是某个方法的问题,还可以用 trace 命令追踪方法的调用耗时分布,看一下到底是哪一行代码耗时长:

BASH
trace com.example.DataExporter formatData

trace 会显示出这个方法内部每个子调用的耗时,定位到瓶颈那一行。Arthas 还有一个很好用的能力是 watch,可以观测某个方法的入参和返回值,在排查“为什么数据特别多、导致拼接循环特别长”这点上,非常直接。当然,Arthas 是线上诊断工具,使用前需要确认安全合规,尽量不要在核心交易链路高峰期乱用,但在事故发生时它就是一把利器。


4. 死锁不是玄学:jstack 检测机制与经典案例拆解

4.1 jstack 凭什么能检测出死锁?

CPU 飙高和死锁看起来是两个方向的问题——一个烧 CPU,一个卡住不动。但在排查逻辑上,它们高度重叠:大部分并发问题的第一现场,都必须靠线程栈去还原。而当 Java 应用发生死锁时,线程通常不会烧 CPU,而是处于 BLOCKED 或 WAITING 状态,整个服务表现为请求超时、卡死、线程池耗尽。

这里有个容易被忽略的知识点:jstack 其实内置了死锁检测。当你执行 jstack -l 时,如果 JVM 发现了死锁,输出的末尾会有一段明确的提示:

TEXT
Found one Java-level deadlock:
=============================
"thread-A":
waiting to lock monitor 0x00007f2a1c008b28 (object 0x00000000ff2f53e0, a java.lang.Object),
which is held by "thread-B"
"thread-B":
waiting to lock monitor 0x00007f2a1c008970 (object 0x00000000ff2f53e8, a java.lang.Object),
which is held by "thread-A"
 
Java stack information for the threads listed above:
===================================================
...

这段信息直接告诉了你两件事:死锁涉及哪几个线程,以及每个线程在等哪把锁。仔细阅读后面打印的线程栈,就能还原出完整的“锁等待图”:线程 A 持有锁 X 想拿锁 Y,线程 B 持有锁 Y 想拿锁 X,两边谁也不让,死锁就形成了。

jstack 之所以能检测到,是因为 JVM 在 dump 线程栈时,会遍历所有 Java 监视器锁的持有关系,构建一张等待图,然后检查这张图里有没有环。有环,就是死锁。所以排查死锁的第一命令,依然是 jstack。

4.2 经典死锁案例:转账场景的动态顺序死锁

很多人看死锁的八股文案例都懂:两个线程,两把锁,互相等待。但真实线上死锁往往更隐蔽,最常见的一种是“动态顺序死锁”。我拿转账场景举个例子。

假设有两个账户对象,要执行转账操作。代码大概是这样:

JAVA
public void transfer(Account from, Account to, BigDecimal amount) {
synchronized (from) {
synchronized (to) {
from.debit(amount);
to.credit(amount);
}
}
}

表面上看,这个方法是安全的:锁住了转出账户和转入账户,避免了并发操作同一账户的问题。但只要两个线程同时执行方向相反的转账,死锁就来了。比如线程 1 执行 transfer(accountA, accountB),线程 2 执行 transfer(accountB, accountA)。线程 1 先拿到了 accountA 的锁,线程 2 先拿到了 accountB 的锁,然后线程 1 等着拿 accountB,线程 2 等着拿 accountA,互相掐死。

这个问题的本质是锁的顺序不一致,锁的获取顺序是由运行时参数决定的,而不是固定的代码顺序。解决思路很简单:给账户对象设计一个全局唯一的 ID,然后总是先锁 ID 小的那个账户,再加锁 ID 大的那个。这样无论传入顺序怎么变,两个线程抢锁的顺序都一样,死锁自然不可能发生。

JAVA
public void transfer(Account from, Account to, BigDecimal amount) {
Account first = from.id() < to.id() ? from : to;
Account second = first == from ? to : from;
synchronized (first) {
synchronized (second) {
from.debit(amount);
to.credit(amount);
}
}
}

这是一个很典型的“用排序消除动态顺序死锁”的案例。我特意把它写出来,是因为太多人在面试时能背出死锁的四个必要条件,但真到线上,面对这种动态顺序死锁,却不知道从哪里下手。

4.3 不太明显的死锁:协作对象间的回调死锁

除了 synchronized 锁,JUC 包里的显式锁也容易出现死锁,而且 jstack 对 ReentrantLock 的检测同样有效。不过有一种死锁更隐蔽:它不是因为两个线程抢两把锁,而是因为锁的持有者在等待一个协作对象的回调,而这个回调又反向需要同一把锁。

我遇到过这样一个场景。某个缓存组件内部用了读写锁,读操作持有读锁,然后回调一个监听器,监听器里又去调用了该缓存组件的写方法,试图获取写锁。在 Java 的 ReentrantReadWriteLock 里,读锁和写锁是互斥的,同一个线程可以在读锁内获取写锁吗?不行,因为内部有一个 firstReader 之类的机制,但写锁获取时会检查读锁是否被持有,而当前线程持有了读锁,就会发生“自己等自己”的锁升级死锁。这种死锁的表现不是两个线程互相掐,而是同一个线程内,读锁还没释放就去写,导致线程在等待队列里永远等下去。

排查这种问题,核心还是要看线程栈,但需要特别留意那些嵌套的回调关系。栈里可能显示线程持有某把锁,然后又等在一把读写锁上。只要看到“自己等自己”的逻辑,基本就能锁定问题。


5. 别让锁变成地雷:动态顺序死锁与数据库死锁的预防策略

5.1 从锁的粒度到锁的顺序:预防死锁的代码规范

如果说排查事故是“救火”,那么在写代码时防止死锁才是“防火”。我在团队里推行过几条非常实用的死锁预防规范,分享出来给大家参考:

  • 能不用锁就不用锁:对于不可变对象、线程封闭的场景,直接避免锁的使用,自然就没有锁竞争和死锁问题。
  • 缩小锁的范围:不要在锁内做耗时操作,比如网络请求、文件读写、大批量计算。尽量只锁真正需要保护的共享数据。锁范围越大,等待链越长,不仅容易死锁,性能也差。
  • 锁顺序必须全局一致:如果一个系统里要保护多个资源,必须规定一种全局顺序,所有人都按这个顺序加锁,不允许“看心情”哪个先拿哪个后拿。
  • 使用带超时的尝试锁:对于 ReentrantLock,强烈建议用 tryLock(timeout) 而不是无参 lock()。一旦超过预设时间拿不到锁,就选择回滚重试,而不是无限期等待。这样即使真的发生死锁,也能自动暴露而不是永久卡死。
  • 避免在锁内调用外部回调:这条对框架开发尤其重要。你锁住资源后,回调了一个外部注册的监听器,这个监听器里又会去获取别的锁,风险非常高。如果一定要回调,就先把必要的数据拷贝出来,释放锁之后再回调。

5.2 数据库死锁是另一层战场:行锁与索引缺一不可

很多 Java 死锁的讨论停留在 synchronized 和 JUC 层面,忽略了数据库死锁,但线上最常见的死锁其实是数据库层的。两个事务执行顺序交叉的 SQL,互相持有行锁等待对方的行锁,数据库会选择一个事务牺牲掉(回滚)来打破死锁,但业务层面会报死锁异常,影响用户体验。

数据库死锁的预防思路和 Java 层类似:一是要求所有事务按相同顺序访问表和数据行;二是尽可能减少事务持有锁的时间,长事务是死锁温床;三是确保 WHERE 条件能走索引,因为如果没走索引,数据库会锁全表或者更多行,大大增加锁冲突概率。排查数据库死锁,可以用 SHOW ENGINE INNODB STATUS 查看最近一次死锁信息,里面会打印出两个事务各自持有的锁和等待的锁,非常直观。

这里也提醒一句:如果应用层配置了连接池,某些情况下你会看到 jstack 里的线程卡在数据库驱动等待上,比如 WAITING 在 SocketInputStream 上,那么问题可能不是 Java 锁,而是连接池耗尽,底层是数据库慢查询或者死锁。不要只盯着 Java 层看,要结合慢 SQL 日志、连接池监控一起判断。

5.3 分布式锁的坑:Redis 锁超时与释放错乱

现代 Java 系统里,多实例部署很常见,分布式锁几乎是标配。但分布式锁用不好,也会导致一种“伪死锁”:线程 A 获取了 Redis 锁,但业务执行时间过长,锁超时自动过期了;线程 B 拿到锁开始执行;等 A 执行完,它去释放锁,释放的却是 B 的锁。这虽然不叫严格意义上的死锁,但会造成两个线程同时操作同一资源,后果可能比死锁还严重。

解决这类问题的标准做法是:在锁的 value 里存入一个唯一标识(比如 UUID),释放锁时用 Lua 脚本比对 value 一致后才删除。这是分布式锁的一个非常经典的实现细节。预防分布式死锁和资源争用,还需要注意给锁设置一个合理的过期时间,并且在持有锁的临界区里不要做太耗时的操作。


6. 别忽略那些“非典型”线索:锁膨胀、线程饥饿与 CPU 飙高之间的隐秘关联

6.1 锁竞争激烈居然也会让 CPU 变高

很多人以为死锁就是全部卡住、CPU 变低,但真实系统里,如果锁竞争非常激烈,CPU 反而可能升高。原因是:大量线程在尝试获取同一把锁时,会不断进行锁的“自旋”和上下文切换。Java 的 synchronized 锁在竞争不激烈时走偏向锁和轻量级锁,一旦竞争升级,会膨胀为重量级锁,线程会从用户态切换到内核态,被阻塞、唤醒,再切换。这些操作本身就要消耗 CPU 和内核资源。

你在 jstack 里可能会看到大量线程处于 BLOCKED 状态,同时 CPU 使用率却不低。这其实是一个很强的信号:不是死循环,而是锁竞争剧烈。处理方向是:减少锁持有时间、拆分锁粒度、使用读写锁或并发容器,甚至引入无锁数据结构(如 ConcurrentLinkedQueue、LongAdder 等),把这些线程从互相等待里解放出来。

6.2 线程饥饿:不一定死锁,但比死锁更隐蔽

死锁检测相对容易,因为有环结构很显眼。但“线程饥饿”问题,jstack 往往看不出明显异常。比如一个线程池里的线程全部被某个“慢任务”占用,新任务只能排队等待;或者使用公平锁时,某些线程因为优先级问题一直拿不到锁,长时间处于等待状态。表现就是系统整体吞吐下降、某个功能不可用,但 CPU 负载可能并不高。

这时候最好用的工具是线程池监控。你可以统计线程池的 activeCount、queueSize、completedTaskCount,如果队列堆积增长但线程数不涨,需要重点观察是不是核心线程数设置太小。Java 的 ThreadPoolExecutor 默认核心线程满了之后,任务进队列,队列满了才扩容到最大线程数。如果你的队列是无界队列(比如 LinkedBlockingQueue 默认构造),核心线程满后线程数永远不会扩容,任务只会无限堆积,内存也会出问题。这个问题在排查“为什么线程池没反应”时非常常见。

6.3 JVM 参数里藏着的一半答案

很多时候问题明明在 JVM 层,但表现形式和代码无关。比如堆内存设置过小,导致频繁 Full GC,CPU 自然飙高;又比如栈大小设置过大,导致每个线程占用的内存太多,太多线程创建不出来的同时,操作系统频繁换页。排查这类问题,要养成检查启动参数的习惯。-Xmx、-Xms、-XX:MaxMetaspaceSize、-XX:+UseG1GC、-XX:MaxGCPauseMillis 这些参数,都会直接影响 CPU 和内存的表现。

还有一点很容易被忽视:-XX:+HeapDumpOnOutOfMemoryError 这个参数,遇到 OOM 时能自动 dump 堆快照,后期分析非常有价值。同理,-XX:+ExitOnOutOfMemoryError 则会在 OOM 时直接让 JVM 退出,这样容器平台可以自动重启,避免一个已经“病入膏肓”的进程继续带病运行。这些参数平时就加上,远比故障时再想办法要强。


7. 我的完整排查清单:从报警到修复的半小时作战流程

最后把整个流程整合成一张可以直接照做的作战清单。这套流程我用了很多年,在多次 CPU 飙高和死锁事故里都派上了用场。

  1. 收到报警后冷静确认:先用 uptime 看 load,free -h 看内存,df -h 看磁盘,排除不是磁盘满或内存泄漏导致的问题假象。
  2. top -c 锁定进程:找到高 CPU 的 Java 进程 PID,记录 CPU 使用率、内存占用、运行的时长。
  3. top -Hp 定位线程:记录 CPU 占用最高的前 5 个线程 TID,并转成十六进制备用。
  4. 连抽 jstack:间隔 5 秒连抽三次,保存到文件,同时记录时间点,方便和监控曲线对应。
  5. jstat 看 GC:通过 jstat -gcutil 观察 GC 频率和耗时,判断是否由 GC 引起。
  6. 分析线程栈:重点关注 RUNNABLE 状态的线程栈顶;找 nid= 对应的高 CPU 线程;对比三次栈是否一致。
  7. 判断死锁:检查 jstack 尾部是否有 Found one Java-level deadlock,如果有,按提示分析锁持有关系。
  8. 必要时上 Arthas:thread -n 3 快速定位,trace 方法耗时,watch 入参出参,动态分析无源码场景。
  9. 结合业务定位根因:根据栈里的类名、方法名,回到业务代码,分析是循环、正则、序列化、锁等待还是 GC 问题。
  10. 修复后验证:上线后观察 CPU 曲线、线程池活跃度、GC 曲线,确认问题不再复现;如果问题偶发,保留现场多个 dump 文件,后续持续分析。

在整个排查过程中,我个人的体会是:最快的排查路径,往往是先确认“死锁、GC、死循环、锁竞争”这四类问题中的哪一类,再决定用哪个工具深入。 很多时候你看完栈,只需要几分钟就能锁定位;但如果一上来就乱翻代码、乱试参数,很可能一整天都找不出来。工具本身不复杂,复杂度在于你能否快速把现场信息串成一条完整的证据链。

另外再分享一个小技巧:如果 CPU 飙高发生在容器环境里,注意看 top 里的 CPU 百分比是否是宿主机的全量核心数,还是容器配额对应的核心数。有时候容器明明只分配了 2 个核,但实际占满后,监控制度上看起来是 200%,那反而说明问题不大,线程数也不多;如果把宿主机 32 核全跑满,那才是真正的灾难。多了解一点容器 CPU 限制的原理,排查时就能少走不少弯路。

基于Python+Open CV的手势识别算法设计
伴随着人工智能时代的到来,人机交互的领域也逐渐成为研究的一大方向;其中,手势识别是人机交互领域的一项关键技术,自此手势识别也迎来了一波高潮,近几年无论是在消费领域、电子领域、数码领域、家电领域甚至汽车领域上,都能或多或少的见到手势识别的身影。 手势识别在设计智能高效的人机界面方面具有至关重要的作用, 目前手势识别已应用到手语识别、智能监控、到虚拟现实等各个领域,手势识别的原理都是利用各种传感器(例如红外、摄像头等)对手部的形态进行捕捉并进行建模,形成一个模型信息的序列帧,而后将这些信息序列转换为机器能够识别的相对应指令(例如打开、切换菜单、移动等)来完成控制。 采用Python的集成开发环境Pycharm进行本次课程设计,在Pycharm中进行需要库(模块)的下载,调取电脑摄像头,按帧读取摄像头采集到的头像,形态学处理,图像旋转(由于摄像头采集到的图像是镜像,需要用cv2.flip将摄像头采集到的图像进行处理),选取图片中固定位置作为手势输入,用红线画出手势识别框,基于hsv的肤色检测,进行高斯滤波,找出轮廓,求出图像中手势的凹凸点,手指间角度求取。
努力学习前端的小陈
ArcGIS Pro入门制图教程
地理信息系统 (GIS) 是一种使用地图显示和分析数据的方式。在本教程中,您将学习桌面 GIS 应用程序 ArcGIS Pro 的基础知识。新加坡的一家旅行社希望制作一款宣传册,用于向游客介绍距离市中心热门目的地最近的火车站。该宣传册将与带有文本信息的地图相结合,并在城市的自助设备中出售。您将帮助该旅行社绘制旅游景点的地图,分析其与火车站的距离以及更改地图的外观以使其在视觉上更具吸引力。在 ArcGIS Pro 中,地图和数据通常被组织在一个工程中。开始制作地图之前,您将创建一个工程。
科研online
ArcGIS Pro 布局创建与地图加载全流程解析
本文详细解析了ArcGIS Pro中布局创建与地图加载的全流程。针对从ArcMap转来的用户,重点阐述了布局与地图解耦的核心设计理念,并提供了从新建布局、设置参考比例尺、加载地图框到深度控制与精细化排版的实用技巧,帮助用户高效制作专业地图。
您的账号已被封禁
ArcGIS PRO布局视图避坑指南:地图框添加与专题图制作的5个关键步骤
本文针对ArcGIS PRO用户在布局视图中制作专题图时遇到的常见问题,提供了地图框添加与专题图制作的5个关键步骤避坑指南。从理解布局视图思维、数据框预处理、地图元素协同配置,到深化视觉层次与最终输出检查,系统讲解了如何高效产出严谨美观的专业地图,帮助用户跨越从数据分析到地图输出的最后一公里。
冰炭不同炉
ROS-CV-ImageConverter:将ROS图像转换为OpenCV(cv :: Mat)类型的图像
ROS-CV图像转换器 依存关系 cv_bridge(ROS软件包)
Willis Wang
计算机视觉图像处理-CV2与图像插值算法
用最近邻插值与双线性插值原理完成图像缩放 最近邻插值,是指将目标图像中的点,对应到源图像中后,找到最相邻的整数点,作为插值后的输。缺点:使用最近邻插值算法处理图像放大时,在图象中可能出现明显的块状效应 双线性插值,在两个方向上做三次线性插值。使用双线性插值算法处理图像放大时,在图象中可能出现马赛克 代码 import cv2 img = cv2.imread(’./xiabang.jpg’, cv2.IMREAD_UNCHANGED) #缩放比例 scale_percent = 0.3 width = int(img.shape[1] * scale_percent) height = int
weixin_38697274
基于水平集CV模型的图像分割(Matlab代码)
基于水平集CV模型的图像分割(Matlab代码),全套代码
小宇QAQ
导向滤波(guide_filter)的python实现
导向滤波(guide_filter)的python实现,可以结合暗通道;理论实现比较好的图像去噪效果。
zachzhan_g
ArcGIS Pro 如何新建布局
你是否已经习惯了在ArcGIS中数据视图和布局视图之间来回切换,到了ArcGIS Pro中却找不到二者之间切换的按钮,即使新建布局后却发现地图怎么却是一片空白。从上面的图中可以看到,虽然新建了布局,但是地图还是空白的,如果想要显示地图还需要加载一下,将地图加载进来。在新建的布局上绘制一个框,作为地图显示的范围,绘制后可以看到地图已经完成加载,如下图所示。在菜单栏上选择插入,点击新建布局下拉箭头,选择一个合适的尺寸,如下图所示。点击后完成布局的新建,新建的布局如下图所示。
水经注GIS
ArcGIS Pro数据修复与图层管理实战指南
本文是ArcGIS Pro数据修复与图层管理的实战指南。针对数据源丢失导致的“红色叹号”问题,详细讲解了一键批量修复和进阶手动修复策略,并分享了使用相对路径、打包工程等防患于未然的黄金法则。同时,深入介绍了如何利用图层组进行高效的地图内容组织、比例尺控制与批量操作,帮助用户构建清晰、智能的专业地图,大幅提升GIS项目管理效率。
Tomato
ArcGIS Pro布局设计实战:从空白页面到专业地图输出的完整工作流
本文详细解析了ArcGIS Pro中从“新建布局”开始,到输出专业地图的完整工作流。内容涵盖布局哲学、地图框深度运用、制图元素集成及视觉排版等核心环节,旨在帮助中级用户掌握项目驱动的现代化制图方法,实现从数据到出版级地图的精准转化。
AnjneyMidha
ArcGIS PRO布局视图避坑指南:地图框添加与坐标系设置的5个常见错误
本文针对ArcGIS PRO用户在布局视图中常遇的难题,重点解析了地图框添加与坐标系设置的5个常见错误。从地图框的创建逻辑、坐标系冲突的根源剖析,到地图范围控制、元素联动更新以及打印导出设置,提供了一套完整的避坑指南与实战解决方案,帮助用户高效、精准地完成地图制图与输出工作。
重离子猫猫
ArcGIS Pro布局设计避坑指南:为什么你的地图总是显示空白?
本文深入解析ArcGIS Pro布局设计中地图显示空白的常见问题,提供从基础操作到高级排错的完整解决方案。重点讲解地图框的正确使用方法、布局元素配置技巧,以及多地图框协同工作等进阶功能,帮助用户快速掌握专业地图制作的核心技术。
习翔宇
CV算法(MATLAB)
chan 和 vese 提出的经典CV模型
beastLOVE
GrabCut:使用opencv-python cv2.grabCut交互式剪切图像
GrabCut 使用opencv-python cv2.grabCut交互式剪切图像
Aaron Gary
Opencv-Python图像透视变换cv2.warpPerspective的示例
今天小编就为大家分享一篇关于Opencv-Python图像透视变换cv2.warpPerspective的示例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
weixin_38711369
leetcodecv-Kylin:CV算法岗面经&LeetCode刷题总结
leetcode cv Kylin CV算法岗面经 & LeetCode刷题总结 不断更新中。。。。 面试&笔试经验 LeetCode
weixin_38499553
基恩士CV-X系列相机控制器用户手册CV-X Series Users Manual_CHS.pdf
基恩士CV-X系列相机控制器用户手册CV-X Series Users Manual_CHS真的很不错,
weixin_43905342
ArcGIS布局视图方向调整与优化技巧
地图布局方向是GIS制图的基础设置,直接影响空间数据的可视化效果。横向(Landscape)和竖向(Portrait)布局通过调整页面长宽比例,可优化不同地理要素的展示方式。在ArcGIS等专业制图软件中,方向设置会联动影响比例尺、图例等核心元素的自动适配逻辑。本文以A4纸张为例,详解通过页面设置、Python脚本批处理等技术手段实现布局方向的高效调整,并针对比例尺失准、图例溢出等典型问题提供工程解决方案。特别适用于带状区域地图制作等需要最大化利用版面空间的场景,可提升40%以上的图面利用率。
塞音菩光
ArcGIS Pro 3.4必学新功能:符号系统与布局视图的可见性联动(含省时技巧)
ArcGIS Pro 3.4引入了符号系统与布局视图的可见性联动功能,通过唯一值符号化和复选框控制,实现原子级要素显示/隐藏。这一创新极大提升了制图效率,支持在符号系统窗格、内容窗格和布局视图中同步操作,特别适合城市规划、环境监测等需要动态展示的场景。
t8u9v0
ArcGIS Pro 布局创建与地图加载全攻略
本文详细解析了ArcGIS Pro中布局与地图分离的设计哲学,并提供了从新建布局到加载地图的完整操作指南。重点介绍了如何通过“插入”选项卡新建布局、选择合适的页面尺寸,以及使用地图框工具将项目中的地图动态链接至布局。文章还涵盖了地图范围控制、比例尺锁定、图例添加等深度定制技巧,帮助用户高效创建专业地图并导出为高质量成果。
milk8
ArcGIS多图布局实战:从数据框管理到批量导出的完整指南
在地理信息系统(GIS)制图领域,将多张地图高效整合到单一版面是提升分析报告专业性与表现力的关键技术。其核心原理在于理解并运用数据框与布局视图的分离机制,通过独立的数据框承载不同区域或专题的地理数据,并在统一的布局视图中进行精确排版与视觉整合。这项技术的核心价值在于实现了制图流程的标准化与自动化,避免了传统拼图方式带来的效率低下与更新困难问题,尤其适用于区域对比、时间序列分析、综合评估报告等需要多视角、多维度展示地理信息的应用场景。本文聚焦于ArcGIS Pro平台,深入剖析了多图布局中数据框范围联动、地图
aaa1231722
monolithic-cv:CV算法的集合
单片-cv 计算机视觉算法转储
晨曦姜
改进的cv图像分割
改进的cv图像分割,对学习cv模型有帮助
a904235765
C++实现基于暗通道与导向滤波的图像去雾算法
资源下载链接为: https://pan.quark.cn/s/1bfadf00ae14 在图像处理领域,图像去雾技术用于消除大气散射导致的模糊,提升图像清晰度和视觉质量。本文将介绍一种基于暗通道和导向滤波的图像去雾算法,并探讨如何使用C++和OpenCV库实现。 暗通道理论由Jia等人于2006年提出。他们发现自然场景中存在一些低亮度像素,通常位于无直射光区域。这些像素被称为暗通道像素,可用于估计大气散射模型中的透射率。具体方法是将图像分块,在每块中找到最暗像素值作为暗通道像素。 大气散射模型是图像去雾的基础,描述了光线在大气中传播时的散射影响。模型公式为: I(x)=T(x)×J(x)+A×(1−T(x)) 其中,T(x)是透射率,J(x)是无雾图像亮度,A是全局大气光。透射率与散射程度成反比,无雾图像亮度反映物体本身色彩。 利用暗通道先验,可以近似估计透射率。假设D(x)为暗通道像素,透射率T(x)可通过迭代公式计算: T k+1 (x)= max(D)+ϵ D(x) +(1− max(D)+ϵ D(x) )×T k (x) 其中,k是迭代次数,ϵ是小常数,用于避免除零。 估计透射率后,使用导向滤波器平滑透射率图,减少噪声和边缘失真。导向滤波是一种自适应局部滤波方法,可保持图像边缘细节,同时进行平滑处理。在图像去雾中,它根据图像梯度信息指导滤波过程,更好地恢复图像清晰度。 通过大气散射模型,可得到去雾后的图像: J out (x)= T(x) I(x)−A×(1−T(x)) +A 在C++中,可借助OpenCV库处理图像数据。首先读取输入图像,然后提取暗通道,估计透射率,应用导向滤波,最终恢复无雾图像。OpenCV提供了丰富的图像处理函数,如cv::split用于分离通道,cv::min用于找最小值,cv::filter2D用于导向滤波,cv::imwrite用于保存
KaiyuanCode
cv模型图像分割matlab源程序
cv模型 matlab 图像分割源码,逻辑清晰,注释详尽。
phoenix01
CV图像分割
从pud找到的CV图像分割代码,代码的通过较少的迭代次数就可以实现图像的分割,对学习CV分割有帮助。
a904235765
ArcGIS Pro 3.0 布局视图实战:5分钟搞定专业地图的图例、比例尺与指北针
本文详细介绍了ArcGIS Pro 3.0布局视图的实战技巧,帮助用户在5分钟内高效添加图例、比例尺与指北针,打造专业地图。通过智能图例、动态比例尺和现代化指北针设计,提升制图效率与美观度,特别适合GIS初学者和从ArcMap迁移的用户。
weixin_30652491
ArcGIS Pro界面突然消失?3种恢复方法+自定义布局技巧
本文针对ArcGIS Pro用户常见的操作界面元素突然消失问题,提供了三种核心恢复方法:通过“视图”功能区一键唤回、利用“重置窗格”命令恢复默认布局,以及通过应用程序设置进行深度恢复。文章还深入讲解了如何通过停靠、分组窗格以及自定义功能区等技巧,打造高效个性化的操作界面,帮助用户从被动解决问题转向主动优化工作环境。
nnn11
UG二次开发之 三面摆正体代码分析
CIUGUIBlock 是一个从UIBlock 派生的一个类,为什么要从UIBlock 派生出CIUGUIBlock,这是为了兼容低版的UG。如果我们不从的UIBlock 派生控件类对象指针,在UG 8.5以下的版本,会出现编译错误的问题。这是一个简单的入门功能,包括了不少的常用的UF函,下面我们将结合成品代码一起分析一下常用的函数,这对初学者是必要的。根据创建好的UI控件,在 initialize_cb 中创建控件的指针对象。//根据选定的面,指定 X,Y坐标系轴。//根据变换的矩阵,平移实体。
广东大龄码农