详解Java线程堆栈
写在前面： 线程堆栈应该是多线程类应用程序非功能问题定位的最有效手段，可以说是杀手锏。线程堆栈最擅长与分析如下类型问题：
系统无缘无故CPU过高。
系统挂起，无响应。
系统运行越来越慢。
性能瓶颈（如无法充分利用CPU等）
线程死锁、死循环，饿死等。
由于线程数量太多导致系统失败（如无法创建线程等）。
如何解读线程堆栈
如下面一段Java源代码程序：
package org.ccgogoing.study.stacktrace;
/**
* @Author: LuoChong400
* @Description: 测试线程
* @Date: Create in 07:27 PM 2017/12/08
*/
public class MyTest {
Object obj1 = new Object();
Object obj2 = new Object();
public void fun1() {
synchronized (obj1) {
fun2();
}
}
public void fun2() {
synchronized (obj2) {
while (true) { //为了打印堆栈，该函数堆栈分析不退出
System.out.print("");
}
}
}
public static void main(String[] args) {
MyTest aa = new MyTest();
aa.fun1();
}
}
在Idea 中运行该程序，然后按下CTRL+BREAK键，打印出线程堆栈信息如下：
Full thread dump Java HotSpot(TM) 64-Bit Server VM (24.79-b02 mixed mode): "Service Thread" daemon prio=6 tid=0x000000000c53b000 nid=0xca58 runnable [0x0000000000000000] java.lang.Thread.State: RUNNABLE "C2 CompilerThread1" daemon prio=10 tid=0x000000000c516000 nid=0xd390 waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE "C2 CompilerThread0" daemon prio=10 tid=0x000000000c515000 nid=0xcbac waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE "Monitor Ctrl-Break" daemon prio=6 tid=0x000000000c514000 nid=0xd148 runnable [0x000000000caee000] java.lang.Thread.State: RUNNABLE at java.net.SocketInputStream.socketRead0(Native Method) at java.net.SocketInputStream.read(SocketInputStream.java:152) at java.net.SocketInputStream.read(SocketInputStream.java:122) at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:283) at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:325) at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:177) - locked <0x00000000d7858b50> (a java.io.InputStreamReader) at java.io.InputStreamReader.read(InputStreamReader.java:184) at java.io.BufferedReader.fill(BufferedReader.java:154) at java.io.BufferedReader.readLine(BufferedReader.java:317) - locked <0x00000000d7858b50> (a java.io.InputStreamReader) at java.io.BufferedReader.readLine(BufferedReader.java:382) at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:64) "Attach Listener" daemon prio=10 tid=0x000000000ad4a000 nid=0xd24c runnable [0x0000000000000000] java.lang.Thread.State: RUNNABLE "Signal Dispatcher" daemon prio=10 tid=0x000000000c1a8800 nid=0xd200 waiting on condition [0x0000000000000000] java.lang.Thread.State: RUNNABLE "Finalizer" daemon prio=8 tid=0x000000000ace6000 nid=0xcd74 in Object.wait() [0x000000000c13f000] java.lang.Thread.State: WAITING (on object monitor) at java.lang.Object.wait(Native Method) - waiting on <0x00000000d7284858> (a java.lang.ref.ReferenceQueue$Lock) at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135) - locked <0x00000000d7284858> (a java.lang.ref.ReferenceQueue$Lock) at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:151) at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:209) "Reference Handler" daemon prio=10 tid=0x000000000ace4800 nid=0xce34 in Object.wait() [0x000000000bf4f000] java.lang.Thread.State: WAITING (on object monitor) at java.lang.Object.wait(Native Method) - waiting on <0x00000000d7284470> (a java.lang.ref.Reference$Lock) at java.lang.Object.wait(Object.java:503) at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:133) - locked <0x00000000d7284470> (a java.lang.ref.Reference$Lock) "main" prio=6 tid=0x000000000238e800 nid=0xc940 runnable [0x00000000027af000] java.lang.Thread.State: RUNNABLE at org.ccgogoing.study.stacktrace.MyTest.fun2(MyTest.java:22) - locked <0x00000000d77d50c8> (a java.lang.Object) at org.ccgogoing.study.stacktrace.MyTest.fun1(MyTest.java:15) - locked <0x00000000d77d50b8> (a java.lang.Object) at org.ccgogoing.study.stacktrace.MyTest.main(MyTest.java:29) "VM Thread" prio=10 tid=0x000000000ace1000 nid=0xd0a8 runnable "GC task thread#0 (ParallelGC)" prio=6 tid=0x00000000023a4000 nid=0xd398 runnable "GC task thread#1 (ParallelGC)" prio=6 tid=0x00000000023a5800 nid=0xcc20 runnable "GC task thread#2 (ParallelGC)" prio=6 tid=0x00000000023a7000 nid=0xb914 runnable "GC task thread#3 (ParallelGC)" prio=6 tid=0x00000000023a9000 nid=0xd088 runnable "VM Periodic Task Thread" prio=10 tid=0x000000000c53f000 nid=0xc1b4 waiting on condition JNI global references: 138 Heap PSYoungGen total 36864K, used 6376K [0x00000000d7280000, 0x00000000d9b80000, 0x0000000100000000) eden space 31744K, 20% used [0x00000000d7280000,0x00000000d78ba0d0,0x00000000d9180000) from space 5120K, 0% used [0x00000000d9680000,0x00000000d9680000,0x00000000d9b80000) to space 5120K, 0% used [0x00000000d9180000,0x00000000d9180000,0x00000000d9680000) ParOldGen total 83456K, used 0K [0x0000000085800000, 0x000000008a980000, 0x00000000d7280000) object space 83456K, 0% used [0x0000000085800000,0x0000000085800000,0x000000008a980000) PSPermGen total 21504K, used 3300K [0x0000000080600000, 0x0000000081b00000, 0x0000000085800000) object space 21504K, 15% used [0x0000000080600000,0x0000000080939290,0x0000000081b00000)
在上面这段堆栈输出中，可以看到有很多后台线程和main线程，其中只有main线程属于Java用户线程，其他几个都是虚拟机自动创建的，我们分析的过程中，只关心用户线程即可。
从上面的main线程中可以很直观的看到当前线程的调用上下文，其中一个线程的某一层调用含义如下：
at MyTest.fun1(MyTest.java:15) | | | | | | | +-----当前正在调用的函数所在的源代码文件的行号 | | +------------当前正在调用的函数所在的源代码文件 | +---------------------当前正在调用的方法名 +---------------------------当前正在调用的类名
另外，堆栈中有：- locked <0x00000000d77d50b8> (a java.lang.Object)语句，表示该线程已经占有柯锁<0x00000000d77d50b8>,尖括号中表示锁ID，这个事系统自动产生的，我们只需要知道每次打印的堆栈，同一个ID表示是同一个锁即可。每一个线程堆栈的第一行含义如下：
"main" prio=1 tid=0x000000000238e800 nid=0xc940 runnable [0x00000000027af000] | | | | | | | | | | | +--线程占用内存地址 | | | | +-----------线程的状态 | | | +----线程对应的本地线程id号 | | +-------------------线程id | +--------------------------线程优先级 +-------------------------------线程名称 其中需要说明的是，线程对应的本地线程id号，是指Java线程所对应的虚拟机中的本地线程。由于Java是解析型语言，执行的实体是Java虚拟机，因此Java语言中的线程是依附于虚拟机中的本地线程来运行的，实际上是本地线程在执行Java线程代码。
锁的解读
从上面的线程堆栈看，线程堆栈中包含的直接信息为：线程的个数，每个线程调用的方法堆栈，当前锁的状态。线程的个数可以直接数出来；线程调用的方法堆栈，从下向上看，即表示当前的线程调用了哪个类上的哪个方法。而锁得状态看起来稍微有一点技巧。与锁相关的信息如下：
当一个线程占有一个锁的时候，线程的堆栈中会打印--locked<0x00000000d77d50c8>
当一个线程正在等待其它线程释放该锁，线程堆栈中会打印--waiting to lock<0x00000000d77d50c8>
当一个线程占有一个锁，但又执行到该锁的wait()方法上，线程堆栈中首先打印locked，然后又会打印--waiting on
<0x00000000d77d50c8>
线程状态的解读
借助线程堆栈，可以分析很多类型的问题，CPU的消耗分析即是线程堆栈分析的一个重要内容；
处于TIMED_WAITING、WAITING状态的线程一定不消耗CPU。处于RUNNABLE的线程，要结合当前代码的性质判断，是否消耗CPU。
如果是纯Java运算代码，则消耗CPU。
如果是网络IO，很少消耗CPU。
如果是本地代码，要结合本地代码的性质判断（可以通过pstack、gstack获取本地线程堆栈），如果是纯运算代码，则消耗CPU，如果被挂起，则不消耗CPU，如果是IO，则不怎么消耗CPU。
如何借助线程堆栈分析问题
线程堆栈在定位如下类型的问题上非常有帮助：
线程死锁的分析
Java代码导致的CPU过高分析
死循环分析
资源不足分析
性能瓶颈分析
线程死锁分析
死锁的概念就不做过多解释了，不明白的可以去网上查查；
两个或超过两个线程因为环路的锁依赖关系而形成的锁环，就形成了真正的死锁，如下为死锁喉打印的堆栈：
Found one Java-level deadlock: ============================= "org.ccgogoing.study.stacktrace.deadlock.TestThread2": waiting to lock monitor 0x000000000a9ad118 (object 0x00000000d77363d0, a java.lang.Object), which is held by "org.ccgogoing.study.stacktrace.deadlock.TestThread1" "org.ccgogoing.study.stacktrace.deadlock.TestThread1": waiting to lock monitor 0x000000000a9abc78 (object 0x00000000d77363e0, a java.lang.Object), which is held by "org.ccgogoing.study.stacktrace.deadlock.TestThread2" Java stack information for the threads listed above: =================================================== "org.ccgogoing.study.stacktrace.deadlock.TestThread2": at org.ccgogoing.study.stacktrace.deadlock.TestThread2.fun(TestThread2.java:35) - waiting to lock <0x00000000d77363d0> (a java.lang.Object) - locked <0x00000000d77363e0> (a java.lang.Object) at org.ccgogoing.study.stacktrace.deadlock.TestThread2.run(TestThread2.java:22) "org.ccgogoing.study.stacktrace.deadlock.TestThread1": at org.ccgogoing.study.stacktrace.deadlock.TestThread1.fun(TestThread1.java:33) - waiting to lock <0x00000000d77363e0> (a java.lang.Object) - locked <0x00000000d77363d0> (a java.lang.Object) at org.ccgogoing.study.stacktrace.deadlock.TestThread1.run(TestThread1.java:20) Found 1 deadlock.
从打印的堆栈中我们能看到"Found one Java-level deadlock:",即如果存在死锁情况,堆栈中会直接给出死锁的分析结果.
当一组Java线程发生死锁的时候,那么意味着Game Over,这些线程永远得被挂在那里了,永远不可能继续运行下去。当发生死锁的线程在执行系统的关键功能时，那么这个死锁可能会导致整个系统瘫痪，要想恢复系统，临时也是唯一的规避方法是将系统重启。然后赶快去修改导致这个死锁的Bug。
注意：死锁的两个或多个线程是不消耗CPU的，有的人认为CPU100%的使用率是线程死锁导致的，这个说法是完全错误的。死循环，并且在循环中代码都是CPU密集型，才有可能导致CPU的100%使用率，像socket或者数据库等IO操作是不怎么消耗CPU的。
相关推荐
-
java多线程之线程,进程和Synchronized概念初解
一.进程与线程的概念 (1)在传统的操作系统中,程序并不能独立运行,作为资源分配和独立运行的基本单位都是进程. 在未配置 OS 的系统中,程序的执行方式是顺序执行,即必须在一个程序执行完后,才允许另一个程序执行:在多道程序环境下,则允许多个程序并发执行.程序的这两种执行方式间有着显著的不同.也正是程序并发执行时的这种特征,才导致了在操作系统中引入进程的概念. 自从在 20 世纪 60 年代人们提出了进程的概念后,在 OS 中一直都是以进程作为能拥有资源和独立运行的基本单位的.直到 20 世纪 8
-
浅析Java线程的中断机制
线程中断机制提供了一种方法,用于将线程从阻塞等待中唤醒,尝试打断目标线程的现有处理流程,使之响应新的命令.Java 留给开发者这一自由,我们应当予以善用. 今天我们聊聊 Java 线程的中断机制. 线程中断机制提供了一种方法,有两种常见用途: 将线程从阻塞等待中唤醒,并作出相应的"受控中断"处理. 尝试告知目标线程:请打断现有处理流程,响应新的命令. 以第一种用途为例,请看以下代码: synchronized (lock) { try { while (!check()) { lock
-
以银行取钱为例模拟Java多线程同步问题完整代码
简单了解下在操作系统中进程和线程的区别: 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程.(进程是资源分配的最小单位) 线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小.(线程是cpu调度的最小单位) 线程和进程一样分为五个阶段:创建.就绪.运行.阻塞.终止. 多进程是指操作系统能同时运行多个任务(程序). 多线程是指在同一程序中有多个顺序流在执行.首先存钱取钱的这个操作,应该是线程操作的
-
Java语言多线程终止中的守护线程实例
Java中线程分为两种类型:用户线程和守护(服务)线程.通过Thread.setDaemon(false)设置为用户线程;通过Thread.setDaemon(true)设置为守护线程;不设置则默认为用户线程. 结束单线程用 Thread.interrupt() 方法,多线程结束则需要设置守护线程.当不存在用户线程时,守护线程就会全部终结(可以理解为:守护线程是服务线程,用户线程是被服务线程,用户线程(被服务线程)全都没有了,服务线程便没有存在意义而自动终结) 例子: class StopThr
-
java集合框架线程同步代码详解
List接口的大小可变数组的实现.实现了所有可选列表操作,并允许包括null在内的所有元素.除了实现List接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小.(此类大致上等同于Vector类,除了此类是不同步的.)size.isEmpty.get.set.iterator和listIterator操作都以固定时间运行.add操作以分摊的固定时间运行,也就是说,添加n个元素需要O(n)时间.其他所有操作都以线性时间运行(大体上讲).与用于LinkedList实现的常数因子相比,此实现的
-
java线程的基础实例解析
java中建立线程可以有两种方式,分别是继承Thread类和实现Runnable接口. 继承Thread public class MyThread extends Thread{ public MyThread(String name){ super(name); } int i; public void run(){ for(i=0;i<5;i++){ System.out.println(getName()+"--"+i); } } public static void m
-
Java终止线程实例和stop()方法源码阅读
了解线程 概念 线程 是程序中的执行线程.Java 虚拟机允许应用程序并发地运行多个执行线程. 线程特点 拥有状态,表示线程的状态,同一时刻中,JVM中的某个线程只有一种状态; ·NEW 尚未启动的线程(程序运行开始至今一次未启动的线程) ·RUNNABLE 可运行的线程,正在JVM中运行,但它可能在等待其他资源,如CPU. ·BLOCKED 阻塞的线程,等待某个锁允许它继续运行 ·WAITING 无限等待(再次运行依赖于让它进入该状态的线程执行某个特定操作) ·TIMED_WAITING 定时
-
java多线程Thread的实现方法代码详解
之前有简单介绍过java多线程的使用,已经Thread类和Runnable类,为了更好地理解多线程,本文就Thread进行详细的分析. start() 我们先来看看API中对于该方法的介绍: 使该线程开始执行:Java 虚拟机调用该线程的 run 方法. 结果是两个线程并发地运行:当前线程(从调用返回给 start 方法)和另一个线程(执行其 run 方法). 多次启动一个线程是非法的.特别是当线程已经结束执行后,不能再重新启动. 用start方法来启动线程,真正实现了多线程运行,这时无需等待r
-
详解Java线程堆栈
写在前面: 线程堆栈应该是多线程类应用程序非功能问题定位的最有效手段,可以说是杀手锏.线程堆栈最擅长与分析如下类型问题: 系统无缘无故CPU过高. 系统挂起,无响应. 系统运行越来越慢. 性能瓶颈(如无法充分利用CPU等) 线程死锁.死循环,饿死等. 由于线程数量太多导致系统失败(如无法创建线程等). 如何解读线程堆栈 如下面一段Java源代码程序: package org.ccgogoing.study.stacktrace; /** * @Author: LuoChong400 * @Des
-
详解JAVA 线程-线程的状态有哪些？它是如何工作的？
线程(Thread)是并发编程的基础,也是程序执行的最小单元,它依托进程而存在. 一个进程中可以包含多个线程,多线程可以共享一块内存空间和一组系统资源,因此线程之间的切换更加节省资源.更加轻量化,也因此被称为轻量级的进程. 线程的状态在 JDK 1.5 之后以枚举的方式被定义在 Thread 的源码中,它总共包含以下 6 个状态: NEW,新建状态,线程被创建出来,但尚未启动时的线程状态: RUNNABLE,就绪状态,表示可以运行的线程状态,它可能正在运行,或者是在排队等待操作系统给它分配 CP
-
一文详解Java线程中的安全策略
目录 一.不可变对象 二.线程封闭 三.线程不安全类与写法 四.线程安全-同步容器 1. ArrayList -> Vector, Stack 2. HashMap -> HashTable(Key, Value都不能为null) 3. Collections.synchronizedXXX(List.Set.Map) 五.线程安全-并发容器J.U.C 1. ArrayList -> CopyOnWriteArrayList 2.HashSet.TreeSet -> CopyOnW
-
详解Java线程池和Executor原理的分析
详解Java线程池和Executor原理的分析 线程池作用与基本知识 在开始之前,我们先来讨论下"线程池"这个概念."线程池",顾名思义就是一个线程缓存.它是一个或者多个线程的集合,用户可以把需要执行的任务简单地扔给线程池,而不用过多的纠结与执行的细节.那么线程池有哪些作用?或者说与直接用Thread相比,有什么优势?我简单总结了以下几点: 减小线程创建和销毁带来的消耗 对于Java Thread的实现,我在前面的一篇blog中进行了分析.Java Thread与内
-
详解Java线程同步器CountDownLatch
Java程序有的时候在主线程中会创建多个线程去执行任务,然后在主线程执行完毕之前,把所有线程的任务进行汇总,以前可以用线程的join方法,但是这个方法不够灵活,我们可以使用CountDownLatch类,实现更优雅,而且使用线程池的话,可没有办法调用线程的join方法的呀! 一.简单使用CountDownLatch 直接使用线程: package com.example.demo.study; import java.util.concurrent.CountDownLatch; public
-
详解Java 线程中断
一.前言 大家肯定都使用过 Java 线程开发(Thread / Runnable),启动一个线程的做法通常是: new Thread(new Runnable( @Override public void run() { // todo sth... } )).start(); 然而线程退出,大家是如何做的呢?一般做法可能不外乎以下两种: 设置一个标志位:true / false 来退出: 强制退出:thread.stop:(我相信,现在应该没人会使用这种方式了,因为JDK也很早就废弃了该方法
-
详解Java线程池的使用及工作原理
一.什么是线程池? 线程池是一种用于实现计算机程序并发执行的软件设计模式.线程池维护多个线程,等待由调度程序分配任务以并发执行,该模型提高了性能,并避免了由于为短期任务频繁创建和销毁线程而导致的执行延迟. 二.线程池要解决什么问题? 说到线程池就一定要从线程的生命周期讲起. 从图中可以了解无论任务执行多久,每个线程都要经历从生到死的状态.而使用线程池就是为了避免线程的重复创建,从而节省了线程的New至Runnable, Running至Terminated的时间:同时也会复用线程,最小化的节省系
-
详解Java线程池是如何重复利用空闲线程的
在Java开发中,经常需要创建线程去执行一些任务,实现起来也非常方便,但如果并发的线程数量很多,并且每个线程都是执行一个时间很短的任务就结束了,这样频繁创建线程就会大大降低系统的效率,因为频繁创建线程和销毁线程需要时间.此时,我们很自然会想到使用线程池来解决这个问题. 使用线程池的好处: 降低资源消耗.java中所有的池化技术都有一个好处,就是通过复用池中的对象,降低系统资源消耗.设想一下如果我们有n多个子任务需要执行,如果我们为每个子任务都创建一个执行线程,而创建线程的过程是需要一定的系统消耗
-
详解Java线程的创建及休眠
一.进程vs线程 1.进程是系统分配资源的最小单位:线程是系统调度的最小单位 2.一个进程中至少要包含一个线程 3.线程必须要依附于继承,线程是进程实质工作的一个最小单位 二.线程的创建方式 继承Thread类 实现线程的创建(2种写法) 1种写法 public class ThreadDemo03 { static class MyThread extends Thread{ @Override public void run(){ System.out.println("线程名称:"
-
一文详解Java线程的6种状态与生命周期
目录 1.线程状态(生命周期) 2.操作线程状态 2.1.新创建状态(NEW) 2.2.可运行状态(RUNNABLE) 2.3.被阻塞状态(BLOCKED) 2.4.等待唤醒状态(WAITING) 2.5.计时等待状态(TIMED_WAITING) 2.6.终止(TERMINATED) 3.查看线程的6种状态 1.线程状态(生命周期) 一个线程在给定的时间点只能处于一种状态. 线程可以有如下6 种状态: New (新创建):未启动的线程: Runnable (可运行):可运行的线程,需要等待操作