详解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的。

(0)

相关推荐

  • java多线程之线程,进程和Synchronized概念初解

    一.进程与线程的概念 (1)在传统的操作系统中,程序并不能独立运行,作为资源分配和独立运行的基本单位都是进程. 在未配置 OS 的系统中,程序的执行方式是顺序执行,即必须在一个程序执行完后,才允许另一个程序执行:在多道程序环境下,则允许多个程序并发执行.程序的这两种执行方式间有着显著的不同.也正是程序并发执行时的这种特征,才导致了在操作系统中引入进程的概念. 自从在 20 世纪 60 年代人们提出了进程的概念后,在 OS 中一直都是以进程作为能拥有资源和独立运行的基本单位的.直到 20 世纪 8

  • Java终止线程实例和stop()方法源码阅读

    了解线程 概念 线程 是程序中的执行线程.Java 虚拟机允许应用程序并发地运行多个执行线程. 线程特点 拥有状态,表示线程的状态,同一时刻中,JVM中的某个线程只有一种状态; ·NEW 尚未启动的线程(程序运行开始至今一次未启动的线程) ·RUNNABLE 可运行的线程,正在JVM中运行,但它可能在等待其他资源,如CPU. ·BLOCKED 阻塞的线程,等待某个锁允许它继续运行 ·WAITING 无限等待(再次运行依赖于让它进入该状态的线程执行某个特定操作) ·TIMED_WAITING 定时

  • 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语言多线程终止中的守护线程实例

    Java中线程分为两种类型:用户线程和守护(服务)线程.通过Thread.setDaemon(false)设置为用户线程;通过Thread.setDaemon(true)设置为守护线程;不设置则默认为用户线程. 结束单线程用 Thread.interrupt() 方法,多线程结束则需要设置守护线程.当不存在用户线程时,守护线程就会全部终结(可以理解为:守护线程是服务线程,用户线程是被服务线程,用户线程(被服务线程)全都没有了,服务线程便没有存在意义而自动终结) 例子: class StopThr

  • java多线程Thread的实现方法代码详解

    之前有简单介绍过java多线程的使用,已经Thread类和Runnable类,为了更好地理解多线程,本文就Thread进行详细的分析. start() 我们先来看看API中对于该方法的介绍: 使该线程开始执行:Java 虚拟机调用该线程的 run 方法. 结果是两个线程并发地运行:当前线程(从调用返回给 start 方法)和另一个线程(执行其 run 方法). 多次启动一个线程是非法的.特别是当线程已经结束执行后,不能再重新启动. 用start方法来启动线程,真正实现了多线程运行,这时无需等待r

  • 浅析Java线程的中断机制

    线程中断机制提供了一种方法,用于将线程从阻塞等待中唤醒,尝试打断目标线程的现有处理流程,使之响应新的命令.Java 留给开发者这一自由,我们应当予以善用. 今天我们聊聊 Java 线程的中断机制. 线程中断机制提供了一种方法,有两种常见用途: 将线程从阻塞等待中唤醒,并作出相应的"受控中断"处理. 尝试告知目标线程:请打断现有处理流程,响应新的命令. 以第一种用途为例,请看以下代码: synchronized (lock) { try { while (!check()) { lock

  • 以银行取钱为例模拟Java多线程同步问题完整代码

    简单了解下在操作系统中进程和线程的区别: 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程.(进程是资源分配的最小单位) 线程:同一类线程共享代码和数据空间,每个线程有独立的运行栈和程序计数器(PC),线程切换开销小.(线程是cpu调度的最小单位) 线程和进程一样分为五个阶段:创建.就绪.运行.阻塞.终止. 多进程是指操作系统能同时运行多个任务(程序). 多线程是指在同一程序中有多个顺序流在执行.首先存钱取钱的这个操作,应该是线程操作的

  • java集合框架线程同步代码详解

    List接口的大小可变数组的实现.实现了所有可选列表操作,并允许包括null在内的所有元素.除了实现List接口外,此类还提供一些方法来操作内部用来存储列表的数组的大小.(此类大致上等同于Vector类,除了此类是不同步的.)size.isEmpty.get.set.iterator和listIterator操作都以固定时间运行.add操作以分摊的固定时间运行,也就是说,添加n个元素需要O(n)时间.其他所有操作都以线性时间运行(大体上讲).与用于LinkedList实现的常数因子相比,此实现的

  • 详解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 (可运行):可运行的线程,需要等待操作

随机推荐