2. 程式人生 > >JVM除錯常用命令——jstack命令與執行緒狀態（3）

JVM除錯常用命令——jstack命令與執行緒狀態（3）

阿新 • • 發佈：2018-12-05

（接上文《JVM除錯常用命令——jstack命令與Java執行緒棧（2）》）

2.1.3.2、當前執行緒呼叫目前執行緒的join方法，等待後者執行完成

join方法可以讓一個執行緒持續等待到另一個執行緒完成執行後，再繼續進行執行。下面我們就來看一下使用join方法讓一個執行緒進入WATING狀態時，在jstack命令結果中的列印效果。

// ......之前的程式碼片段省略
public static void main(String[] args) {
  Thread thread1 = new Thread(new MyThread1(), "thread1");
  Thread thread2 =
 
 new Thread(new MyThread2(thread1), "thread2");
  thread1.start();
  thread2.start();
}
private static class MyThread2 implements Runnable {
  private Thread joinThread;
  public MyThread2(Thread joinThread) {
    this.joinThread = joinThread;
  }
  @Override
  public void run() {
    Thread currentThread =
 
 Thread.currentThread();
    System.out.println("當前執行緒[" + currentThread.getName() + "]使用join進入等待");
    try {
      this.joinThread.join();
    } catch (InterruptedException e) {
      e.printStackTrace(System.out);
    }
    System.out.println("當前執行緒[" + currentThread.getName() + "]已經完成等待");
  }
}
 

private static class MyThread1 implements Runnable {
  @Override
  public void run() {
    Thread currentThread = Thread.currentThread();
    System.out.println("當前執行緒[" + currentThread.getName() + "]正在執行");
  }
}
// ......之後的程式碼片段省略

以上程式碼，我們建立了兩個執行緒Thread1和Thread2，其中Thread2會使用join方法，等待Thread1執行完成後在執行。我們使用debug方式，將以上程式碼的執行效果停滯於如下圖所示的狀態：

在這裡插入圖片描述

如上圖所示的效果，我們將MyThread2類的例項執行到第21行，也就是呼叫join方法的位置，這時MyThread2的執行緒就會進入WATING狀態；而MyThread1類的例項執行到第33行，也就是剛完成System.out方法，但是整個方法還沒有執行結束的位置，這時MyThread1類的例項處於RUNNABLE狀態。接著我們執行jstack命令驗證執行緒狀態，如下：

>jstack 289476
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.144-b01 mixed mode):
.........
"thread2" #15 prio=5 os_prio=0 tid=0x000000001ec53000 nid=0x46064 in Object.wait() [0x000000001fc5f000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x000000076c5c4910> (a java.lang.Thread)
        at java.lang.Thread.join(Thread.java:1252)
        - locked <0x000000076c5c4910> (a java.lang.Thread)
        at java.lang.Thread.join(Thread.java:1326)
        at testThread.TestJoin$MyThread2.run(TestJoin.java:25)
        at java.lang.Thread.run(Thread.java:748)
"thread1" #14 prio=5 os_prio=0 tid=0x000000001ec52000 nid=0x46054 at breakpoint[0x000000001fb5f000]
   java.lang.Thread.State: RUNNABLE
        at testThread.TestJoin$MyThread1.run(TestJoin.java:36)
        at java.lang.Thread.run(Thread.java:748)
.........

從命令結果可以看到，名為thread2的執行緒在“TestJoin$MyThread2”類定義的25行呼叫了join方法，並在join方法中獲得了物件（0x000000076c5c4910）的操作權，繼續執行join方法中的內容，到達了第1252行。在這一行呼叫了wait方法釋放掉物件（0x000000076c5c4910）的操作權，並進入WATING狀態。所以我們可以看當名為thread2的執行緒進入WAITING狀態後，其狀態說明資訊中被標註為“(on object monitor)”，這是因為這種WAITING狀態的本質和2.1.3.1中介紹的呼叫wait方法進入WAITING狀態的本質是一樣的。另外，從join方法的主要程式碼塊中，我們也可以讀到相佐證的原始碼：

在這裡插入圖片描述

2.1.3.3、可重入鎖（包括讀寫分離鎖）呼叫lock方法，並觸發阻塞效果

ReentrantLock和ReentrantReadWriteLock都是AQS同步框架的一個具體實現（關於AQS框架，我們將會在本專題後續的文章中進行詳細講解），那麼基於ReentrantLock或者ReentrantReadWriteLock產生的“阻塞”效果又是怎樣呢？首先上程式碼：

// ......之前的程式碼片段省略
public static void main(String[] args) {
  ReentrantLock myLock = new ReentrantLock();
  // 產生兩個執行緒，使用debug方式，觀察特定效果
  Thread thread1 = new Thread(new MyThread(myLock), "thread1");
  Thread thread2 = new Thread(new MyThread(myLock), "thread2");
  thread1.start();
  thread2.start();
}
private static class MyThread implements Runnable {
  private ReentrantLock myLock;
  MyThread(ReentrantLock myLock) {
    this.myLock = myLock;
  }
  @Override
  public void run() {
    String threadName = Thread.currentThread().getName();
    try {
      myLock.lock();
      System.out.println("thread[" + threadName + "]正在工作......");
    } finally {
      myLock.unlock();
    }
  }
}
// ......之後的程式碼片段省略

之上的程式碼片段很簡單了，不需要再進行過多的解釋，如果讀者對ReentrantLock和ReentrantReadWriteLock不清楚，那麼建議先閱讀網路資料。通過debug模式，我們將以上程式碼停止在以下狀態：

執行緒名為thread1的執行緒呼叫lock方法後，執行到“System.out.println”這句程式碼；由於這時thread1還沒有呼叫unlock方法，所以當執行緒thread2呼叫lock方法時，將會進入阻塞狀態。如下圖所示：

在這裡插入圖片描述

細心的讀者可以發現，在以上使用ReentrantLock或者ReentrantReadWriteLock的除錯資訊中，除錯視窗示意的兩個執行緒好像並沒有提示開發人員“某個執行緒持有了某個物件的鎖”，既是沒有那把“黃色的鎖”，通過jstack命令我們也可以觀察到這一現象：

# jstack 336144

Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.144-b01 mixed mode):
"thread2" #15 prio=5 os_prio=0 tid=0x000000001ea40000 nid=0x462b4 waiting on condition [0x000000001fa4e000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x000000076c5c60b8> (a java.util.concurrent.locks.ReentrantLock$NonfairSync)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:836)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:870)
        at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1199)
        at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:209)
        at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:285)
        at testThread.TestReentrantLock$MyThread.run(TestReentrantLock.java:27)
        at java.lang.Thread.run(Thread.java:748)
		
"thread1" #14 prio=5 os_prio=0 tid=0x000000001ea3f000 nid=0x47cf0 runnable [0x000000001f94e000]
   java.lang.Thread.State: RUNNABLE
        at testThread.TestReentrantLock$MyThread.run(TestReentrantLock.java:28)
        at java.lang.Thread.run(Thread.java:748)

如以上命令結果所示，名叫thread1和thread2的執行緒確實沒有被提示“locked”住了某個物件，只有進入“阻塞”狀態的thread2有一個parking標識——但是thread2確實進入了阻塞狀態，並在在thread呼叫了unlock方法後確實又能夠恢復到RUNNABLE狀態。這實際上就是AQS同步框架的工作效果（後文詳細講解）——這時讀者可以觀察到在WAITING狀態後的標識使用的是“(parking)”而不是“object monitor”。

2.1.3.4、使用LockSupport，並觸發阻塞效果

LockSupport屬於AQS框架的底層支援部分，LockSupport提供了執行緒元語級別的執行/阻塞控制，能夠幫助開發者完成類似ReentrantLock、Semaphore等這樣基於AQS框架的高級別同步工具。有了2.1.3.3中對ReentrantLock阻塞效果的分析後，這裡我們大致檢驗一下直接使用LockSupport讓指定執行緒進入阻塞模式後的效果。同樣，先上程式碼片段（在這裡，讀者如果不清楚LockSupport中主要方法的功能也無所謂，後文將進行詳細介紹）：

// ......之前的程式碼片段省略
private static Object lockObject = new Object();
// 相信不用寫太多註釋了吧。。。。
public static void main(String[] args) {
  Thread thread2 = new Thread(new MyThread2(), "thread2");
  Thread thread1 = new Thread(new MyThread1(thread2), "thread1");
  thread1.start();
  thread2.start();
}
private static class MyThread1 implements Runnable {
  private Thread targetThread;
  public MyThread1(Thread targetThread) {
    this.targetThread = targetThread;
  }
  @Override
  public void run() {
    LockSupport.unpark(targetThread);
    System.out.println("// do somethings");
  }
}
private static class MyThread2 implements Runnable {
  @Override
  public void run() {
    LockSupport.park(lockObject);
    System.out.println("// do somethings");
  }
}
// ......之後的程式碼片段省略

通過debug模式的支援，我們先讓MyThread2呼叫LockSupport.park方法進入阻塞狀態，MyThread1中的LockSupport.unpark方法可以讓前者解除阻塞狀態，但是我們還不忙執行。這時通過jstack命令觀察程序中主要的執行緒狀態如下：

jstack 341584
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.144-b01 mixed mode):
"thread2" #14 prio=5 os_prio=0 tid=0x000000001ea99000 nid=0x53624 waiting on condition [0x000000001faae000]
   java.lang.Thread.State: WAITING (parking)
        at sun.misc.Unsafe.park(Native Method)
        - parking to wait for  <0x000000076c5c4f60> (a java.lang.Object)
        at java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
        at testThread.TestLockSupport$MyThread2.run(TestLockSupport.java:34)
        at java.lang.Thread.run(Thread.java:748)
"thread1" #15 prio=5 os_prio=0 tid=0x000000001ea98800 nid=0x532d0 at breakpoint[0x000000001f9af000]
   java.lang.Thread.State: RUNNABLE
        at testThread.TestLockSupport$MyThread1.run(TestLockSupport.java:26)
        at java.lang.Thread.run(Thread.java:748)

這時我們看到的效果和前文中使用ReentrantLock使執行緒進入“阻塞”狀態的效果是一致的。

====================================
（接下文）

相關推薦

JVM除錯常用命令——jstack命令與執行緒狀態（3）

（接上文《JVM除錯常用命令——jstack命令與Java執行緒棧（2）》） 2.1.3.2、當前執行緒呼叫目前執行緒的join方法，等待後者執行完成 join方法可以讓一個執行緒持續等待到另一個執行緒完成執行後，再繼續進行執行。下面我們就來看一下使用join方法讓一個執行緒進入

Java多執行緒程式設計-（3）-執行緒本地ThreadLocal的介紹與使用

原文出自 : https://blog.csdn.net/xlgen157387/article/details/78114278 ThreadLocal簡介 我們通過上兩篇的學習，我們已經知道了變數值的共享可以使用public static變數的形式，所有的執行緒都使

Netty中的Channel之資料沖刷與執行緒安全（writeAndFlush）

本文首發公眾號與個人部落格：Java貓說 & 貓叔的部落格 | MySelf，轉載請申明出處。 GitHub專案地址 InChat 一個輕量級、高效率的支援多端（應用與硬體Iot）的非同步網路應用通訊框架 前言 本文預設讀者已經瞭解了一定的Netty基礎

程序與執行緒學習（三）之執行緒之使用場合

在對程序、執行緒的學習稍加了解後，不僅會自問在什麼情況下要使用多執行緒？畢竟，對知識的學習而不在於知識本身，而是怎麼使用所學的知識，有什麼侷限性。 但從耗時來講，我對多執行緒做了一些測試：程式如下： 只有一個主執行緒來估計買票時間； #include "stdafx.h"

Android執行緒與執行緒池（一）

前言，學習安卓很久了，一直也沒有學部落格的習慣，下決心從今天開始要養成寫部落格總結學習經驗的好習慣！ 一.Android中執行緒與執行緒池的簡介 在Android中執行緒主要可以分為兩大類：一個用於處理介面相關與使用者互動的執行緒-主執行緒；一個用於處理耗時任務-子執行緒

netty原始碼分析之-EventLoop與執行緒模型（1）

執行緒模型確定來程式碼的執行方式，我們總是必須規避併發執行可能會帶來的副作用，所以理解netty所採用的併發模型的影響很重要。netty使用了被稱為事件迴圈的EventLoop來執行任務來處理在連線的生命週期內發生的事件 執行緒模型 對於Even

執行緒學習（3）

執行緒池 為了避免系統頻繁的建立和銷燬執行緒，我們可以將建立的執行緒進行復用。資料庫中的資料庫連線池也是此意。以下是執行緒池的優點 簡書執行緒池的使用細節 阿里巴巴外掛安裝說明 降低資源消耗。通過重複利用已建立的執行緒降低執行緒建立和銷燬造成的消耗。 提高響應速度。當任務到達時，任

C++ 多執行緒框架（3）：訊息佇列

之前，多執行緒一些基本的東西，包括執行緒建立，互斥鎖，訊號量，我們都已經封裝，下面來看看訊息佇列 我們儘量少用系統自帶的訊息佇列（比如Linux的sys/msgqueue），那樣移植性不是很強，我們希望的訊息佇列，在訊息打包和提取都是用的標準的C++資料結構，當然，

linux執行緒學習（3）

執行緒的同步 1. 互斥量 為什麼要使用互斥量： 當多個執行緒共享相同的記憶體時，需要每一個執行緒看到相同的檢視。當一個執行緒修改變數時，而其他執行緒也可以讀取或者修改這個變數，就需要對這些執行緒同步，確保他們不會訪問到無效的變數 互斥鎖的初始化和銷燬：

多執行緒程式設計（3）——synchronized原理以及使用

一、物件頭   通常在java中一個物件主要包含三部分： 物件頭 主要包含GC的狀態、、型別、類的模板資訊（地址）、synchronization狀態等，在後面介紹。 例項資料：程式程式碼中定義的各種型別的欄位內容。 對齊資料：物件的大小必須是 8 位元組的整數倍，此

JVM除錯常用命令——jstack命令與Java執行緒棧（1）

1 jstack 命令 jstack命令的主要作用是列印指定Java程序中每一個執行緒的工作狀態，以及每個執行緒棧當前的方法執行順序等詳細情況。為什麼jstack命令不和jmap、jinfo、jstat等命令一同講解，而要單獨成文呢？因為通過jstack命令給出的執行緒棧詳細情況，可

JVM除錯常用命令——jstack命令與Java執行緒棧（2）

（接上文《JVM除錯常用命令——jstack命令與Java執行緒棧（1）》） 1.2、jstack中的執行緒關鍵資訊 上一篇文章中我們介紹了jstack命令的基本使用，也列舉了一個比較簡單的示例。雖然之前的文章內容中沒有介紹查詢結果中的一些關鍵資訊，但是這並不影響什麼。本片文章中

學習筆記: jstack與執行緒狀態

jstatck可以列印JVM內部所有執行緒 1、檢視有哪些java程序   2、檢視所有執行緒的資訊 重定向到5579.txt檔案中 jstack 5579 > 5579.txt   3、執行緒的狀態 New: 執行緒還沒有啟動 RUNNABLE：已經在JVM中

Android執行緒中執行“getevent”命令時的執行緒退出（結束）問題

       專案中遇到需要執行shell命令“getevent”獲取座標引數的需求，但是發現無法結束執行該命令的執行緒，後來終於發現解決方法。在此記錄下。        我線上程中通過Process

多執行緒學習（4）：三種實現Java多執行緒的方法：Thread、Callable和Runable 的比較與區別

2018年10月03日 目錄 前言 前言 JVM允許應用程式併發執行多執行緒：最常用的是兩個方法：（1）基礎Thread類，重寫run（）方法；（2）或實現Runnable 介面，實現介面的run（）方法；（3）另外一種方法是：實現callable 介面

VS中的多執行緒（/MT）、多執行緒除錯（/MTd）、多執行緒DLL（/MD）、多執行緒除錯DLL（/MDd）的區別

一種語言的開發環境往往會附帶有語言庫，這些庫就是對作業系統的API的包裝，我們也稱這些語言庫為執行庫 對於MSVC的執行庫（CRT），按照靜態/動態連結，可以分為靜態版和動態版；按照除錯/釋出，可以分為除錯版本和釋出版本；按照單執行緒/多執行緒，可以分為單執行緒版本和多執行

Java多執行緒程式設計-（9）-ThreadLocal造成OOM記憶體溢位案例演示與原理分析

原文出自 : https://blog.csdn.net/xlgen157387/article/details/78298840 案例程式碼 1、首先看一下程式碼，模擬了一個執行緒數為500的執行緒池，所有執行緒共享一個ThreadLocal變數，每一個執行緒執

Java多執行緒程式設計-（6）-兩種常用的執行緒計數器CountDownLatch和迴圈屏障CyclicBarrier

原文出自 : https://blog.csdn.net/xlgen157387/article/details/78218736 倒計時CountDownLatch CountDownLatch是一個非常實用的多執行緒控制工具類，稱之為“倒計時器”，它允許一個或多個執

ava多執行緒程式設計-（4）-執行緒間通訊機制的介紹與使用

原文出自 : https://blog.csdn.net/xlgen157387/article/details/78195817 執行緒間通訊簡介 我們知道執行緒是作業系統中獨立的個體，但是這個單獨的個體之間沒有一種特殊的處理方式使之成為一個整體，執行緒之間沒有任何交

程序與執行緒總結（比較全面）

1.程序和執行緒 1.1 概述: 程序是具有一定獨立功能的程式關於某個資料集合上的一次執行活動,程序是系統進行資源分配和排程的一個獨立單位. 執行緒是程序的一個實體,是CPU排程和分派的基本單位,它是比程序更小的能獨立執行的基本單位.執行緒自己基本上不擁有系統資源,只擁有一點在執行中必不