伺服器如何列印堆棧的數據

❶ 如何在進程崩潰後列印堆棧並防止數據丟失

進程在運行過程中遇到邏輯錯誤, 比如除零, 空指針等等, 系統會觸發一個軟體中斷.
這個中斷會以信號的方式通知進程, 這些信號的默認處理方式是結束進程.
發生這種情況, 我們就認為進程崩潰了.

進程崩潰後, 我們會希望知道它是為何崩潰的, 是哪個函數, 哪行代碼引起的錯誤.
另外, 在進程退出前, 我們還希望做一些善後處理, 比如把某些數據存入資料庫, 等等.

下面, 我會介紹一些技術來達成這兩個目標.

1. 在core文件中查看堆棧信息

如果進程崩潰時, 我們能看到當時的堆棧信息, 就能很快定位到錯誤的代碼.
在 gcc 中加入 -g 選項, 可執行文件中便會包含調試信息. 進程崩潰後, 會生成一個 core 文件.
我們可以用 gdb 查看這個 core 文件, 從而知道進程崩潰時的環境.

在調試階段, core文件能給我們帶來很多便利. 但是在正式環境中, 它有很大的局限:
1. 包含調試信息的可執行文件會很大. 並且運行速度也會大幅降低.
2. 一個 core 文件常常很大, 如果進程頻繁崩潰, 硬碟資源會變得很緊張.

所以, 在正式環境中運行的程序, 不會包含調試信息.
它的core文件的大小, 我們會把它設為0, 也就是不會輸入core文件.
在這個前提下, 我們如何得到進程的堆棧信息呢?

2. 動態獲取線程的堆棧

c 語言提供了 backtrace 函數, 通過這個函數可以動態的獲取當前線程的堆棧.
要使用 backtrace 函數, 有兩點要求:
1. 程序使用的是 ELF 二進制格式.
2. 程序連接時使用了 -rdynamic 選項.
-rdynamic可用來通知鏈接器將所有符號添加到動態符號表中, 這些信息比 -g 選項的信息要少得多.

下面是將要用到的函數說明:
#include <execinfo.h>

int backtrace(void **buffer,int size);
用於獲取當前線程的調用堆棧, 獲取的信息將會被存放在buffer中, 它是一個指針列表。
參數 size 用來指定buffer中可以保存多少個void* 元素。
函數返回值是實際獲取的指針個數, 最大不超過size大小
注意: 某些編譯器的優化選項對獲取正確的調用堆棧有干擾,
另外內聯函數沒有堆棧框架; 刪除框架指針也會導致無法正確解析堆棧內容;

char ** backtrace_symbols (void *const *buffer, int size)
把從backtrace函數獲取的信息轉化為一個字元串數組.
參數buffer應該是從backtrace函數獲取的指針數組,
size是該數組中的元素個數(backtrace的返回值) ;
函數返回值是一個指向字元串數組的指針, 它的大小同buffer相同.
每個字元串包含了一個相對於buffer中對應元素的可列印信息.
它包括函數名，函數的偏移地址, 和實際的返回地址.
該函數的返回值是通過malloc函數申請的空間, 因此調用者必須使用free函數來釋放指針.
注意: 如果不能為字元串獲取足夠的空間, 函數的返回值將會為NULL.

void backtrace_symbols_fd (void *const *buffer, int size, int fd)
與backtrace_symbols 函數具有相同的功能,
不同的是它不會給調用者返回字元串數組, 而是將結果寫入文件描述符為fd的文件中,每個函數對應一行.

3. 捕捉信號

我們希望在進程崩潰時列印堆棧, 所以我們需要捕捉到相應的信號. 方法很簡單.
#include <signal.h>
void (*signal(int signum,void(* handler)(int)))(int);
或者： typedef void(*sig_t) ( int );
sig_t signal(int signum,sig_t handler);
參數說明：
第一個參數signum指明了所要處理的信號類型，它可以是除了SIGKILL和SIGSTOP外的任何一種信號。
第二個參數handler描述了與信號關聯的動作，它可以取以下三種值：
1. 一個返回值為正數的函數的地址, 也就是我們的信號處理函數.
這個函數應有如下形式的定義： int func(int sig); sig是傳遞給它的唯一參數。
執行了signal()調用後，進程只要接收到類型為sig的信號，不管其正在執行程序的哪一部分，就立即執行func()函數。
當func()函數執行結束後，控制權返回進程被中斷的那一點繼續執行。
2. SIGIGN, 忽略該信號.
3. SIGDFL, 恢復系統對信號的默認處理。
返回值： 返回先前的信號處理函數指針，如果有錯誤則返回SIG_ERR(-1)。

注意：
當一個信號的信號處理函數執行時，如果進程又接收到了該信號，該信號會自動被儲存而不會中斷信號處理函數的執行，
直到信號處理函數執行完畢再重新調用相應的處理函數。
如果在信號處理函數執行時進程收到了其它類型的信號，該函數的執行就會被中斷。
在信號發生跳轉到自定的handler處理函數執行後，系統會自動將此處理函數換回原來系統預設的處理方式，
如果要改變此操作請改用sigaction()。

4. 實例

下面我們實際編碼, 看看具體如何在捕捉到信號後, 列印進程堆棧, 然後結束進程.

#include <iostream>
#include <time.h>
#include <signal.h>
#include <string.h>
#include <execinfo.h>
#include <fcntl.h>
#include <map>

using namespace std;

map<int, string> SIG_LIST;

#define SET_SIG(sig) SIG_LIST[sig] = #sig;

void SetSigList(){
SIG_LIST.clear();
SET_SIG(SIGILL)//非法指令
SET_SIG(SIGBUS)//匯流排錯誤
SET_SIG(SIGFPE)//浮點異常
SET_SIG(SIGABRT)//來自abort函數的終止信號
SET_SIG(SIGSEGV)//無效的存儲器引用(段錯誤)
SET_SIG(SIGPIPE)//向一個沒有讀用戶的管道做寫操作
SET_SIG(SIGTERM)//軟體終止信號
SET_SIG(SIGSTKFLT)//協處理器上的棧故障
SET_SIG(SIGXFSZ)//文件大小超出限制
SET_SIG(SIGTRAP)//跟蹤陷阱
}

string& GetSigName(int sig){
return SIG_LIST[sig];
}

void SaveBackTrace(int sig){
//打開文件
time_t tSetTime;
time(&tSetTime);
tm* ptm = localtime(&tSetTime);
char fname[256] = {0};
sprintf(fname, "core.%d-%d-%d_%d_%d_%d",
ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
FILE* f = fopen(fname, "a");
if (f == NULL){
exit(1);
}
int fd = fileno(f);

//鎖定文件
flock fl;
fl.l_type = F_WRLCK;
fl.l_start = 0;
fl.l_whence = SEEK_SET;
fl.l_len = 0;
fl.l_pid = getpid();
fcntl(fd, F_SETLKW, &fl);

//輸出程序的絕對路徑
char buffer[4096];
memset(buffer, 0, sizeof(buffer));
int count = readlink("/proc/self/exe", buffer, sizeof(buffer));
if(count > 0){
buffer[count] = '\n';
buffer[count + 1] = 0;
fwrite(buffer, 1, count+1, f);
}

//輸出信息的時間
memset(buffer, 0, sizeof(buffer));
sprintf(buffer, "Dump Time: %d-%d-%d %d:%d:%d\n",
ptm->tm_year+1900, ptm->tm_mon+1, ptm->tm_mday,
ptm->tm_hour, ptm->tm_min, ptm->tm_sec);
fwrite(buffer, 1, strlen(buffer), f);

//線程和信號
sprintf(buffer, "Curr thread: %d, Catch signal:%s\n",
pthread_self(), GetSigName(sig).c_str());
fwrite(buffer, 1, strlen(buffer), f);

//堆棧
void* DumpArray[256];
int nSize = backtrace(DumpArray, 256);
sprintf(buffer, "backtrace rank = %d\n", nSize);
fwrite(buffer, 1, strlen(buffer), f);
if (nSize > 0){
char** symbols = backtrace_symbols(DumpArray, nSize);
if (symbols != NULL){
for (int i=0; i<nSize; i++){
fwrite(symbols[i], 1, strlen(symbols[i]), f);
fwrite("\n", 1, 1, f);
}
free(symbols);
}
}

//文件解鎖後關閉, 最後終止進程
fl.l_type = F_UNLCK;
fcntl(fd, F_SETLK, &fl);
fclose(f);
exit(1);
}

void SetSigCatchFun(){
map<int, string>::iterator it;
for (it=SIG_LIST.begin(); it!=SIG_LIST.end(); it++){
signal(it->first, SaveBackTrace);
}
}

void Fun(){
int a = 0;
int b = 1 / a;
}

static void* ThreadFun(void* arg){
Fun();
return NULL;
}

int main(){
SetSigList();
SetSigCatchFun();

printf("main thread id = %d\n", (pthread_t)pthread_self());
pthread_t pid;
if (pthread_create(&pid, NULL, ThreadFun, NULL)){
exit(1);
}
printf("fun thread id = %d\n", pid);

for(;;){
sleep(1);
}
return 0;
}

文件名為 bt.cpp
編譯: g++ bt.cpp -rdynamic -I /usr/local/include -L /usr/local/lib -pthread -o bt

主線程創建了 fun 線程, fun 線程有一個除零錯誤, 系統拋出 SIGFPE 信號.
該信號使 fun 線程中斷, 我們注冊的 SaveBackTrace 函數捕獲到這個信號, 列印相關信息, 然後終止進程.
在輸出的core文件中, 我們可以看到簡單的堆棧信息.

5. 善後處理

在上面的例子中, fun 線程被 SIGFPE 中斷, 轉而執行 SaveBackTrace 函數.
此時, main 線程仍然在正常運行.
如果我們把 SaveBackTrace 函數最後的 exit(1); 替換成 for(;;)sleep(1);
main 線程就可以一直正常的運行下去.
利用這個特點, 我們可以做很多其它事情.

游戲的伺服器進程常常有這些線程:
網路線程, 資料庫線程, 業務處理線程. 引發邏輯錯誤的代碼常常位於業務處理線程.
而資料庫線程由於功能穩定, 邏輯簡單, 是十分強壯的.
那麼, 如果業務處理線程有邏輯錯誤, 我們捕捉到信號後, 可以在信號處理函數的最後,
通知資料庫線程保存游戲數據.
直到資料庫線程把游戲信息全部存入資料庫, 信號處理函數才返回.
這樣, 伺服器宕機不會導致回檔, 損失被大大降低.

要實現這個機制, 要求資料庫模塊和業務處理模塊具有低耦合度.
當然, 實際應用的時候, 還有許多細節要考慮.
比如, 業務處理線程正在處理玩家的數據, 由於發生不可預知的錯誤, 玩家的數據被損壞了, 這些玩家的數據就不應該被存入資料庫.

❷ 如何用Jstack把java進程中的堆棧信息輸出到

1.2 Thread Dump特點
1. 能在各種操作系統下使用
2. 能在各種Java應用伺服器下使用
3. 可以在生產環境下使用而不影響系統的性能
4. 可以將問題直接定位到應用程序的代碼行上

1.3 Thread Dump 能診斷的問題
1. 查找內存泄露，常見的是程序里load大量的數據到緩存；
2. 發現死鎖線程；

1.4如何抓取Thread Dump
一般當伺服器掛起,崩潰或者性能底下時,就需要抓取伺服器的線程堆棧(Thread Dump)用於後續的分析. 在實際運行中，往往一次 mp的信息，還不足以確認問題。為了反映線程狀態的動態變化，需要接連多次做threadmp，每次間隔10-20s，建議至少產生三次 mp信息，如果每次 mp都指向同一個問題，我們才確定問題的典型性。

有很多方式可用於獲取ThreadDump, 下面列出一部分獲取方式：
操作系統命令獲取ThreadDump:
Windows:
1.轉向伺服器的標准輸出窗口並按下Control + Break組合鍵, 之後需要將線程堆棧復制到文件中；
UNIX/ linux：
首先查找到伺服器的進程號(process id), 然後獲取線程堆棧.
1. ps –ef | grep java
2. kill -3 <pid>
注意：一定要謹慎, 一步不慎就可能讓伺服器進程被殺死。kill -9 命令會殺死進程。

❸ c語言如何將函數調用堆棧列印出來

可以直接用輸出在函數內部調用時，把調用順序列印出來。

一、一個由C/C++編譯的程序佔用的內存分為以下幾個部分

1、棧區（stack）—由編譯器自動分配釋放，存放函數的參數值，局部變數的值等。其操作方式類似於數據結構中的棧。

2、堆區（heap）—一般由程序員分配釋放，若程序員不釋放，程序結束時可能由OS回收。注意它與數據結構中的堆是兩回事，分配方式倒是類似於鏈表，呵呵。

3、全局區（靜態區）（static）—，全局變數和靜態變數的存儲是放在一塊的，初始化的全局變數和靜態變數在一塊區域，未初始化的全局變數和未初始化的靜態變數在相鄰的另一塊區域。-程序結束後有系統釋放

4、文字常量區—常量字元串就是放在這里的。程序結束後由系統釋放

5、程序代碼區—存放函數體的二進制代碼。

二、常式：

//main.cpp
inta=0;全局初始化區
char*p1;全局未初始化區
main()
{
intb;棧
chars[]="abc";棧
char*p2;棧
char*p3="123456";123456在常量區，p3在棧上。
staticintc=0；全局（靜態）初始化區
p1=(char*)malloc(10);
p2=(char*)malloc(20);
分配得來得10和20位元組的區域就在堆區。
strcpy(p1,"123456");123456放在常量區，編譯器可能會將它與p3所指向的"123456"優化成一個地方。
}

❹ 如何通過網路列印機列印阿里雲伺服器裡面的數據

第一種：
1、將伺服器上的文件通過郵件、qq等方式發到本地電腦上後直接列印。
2、連接伺服器選擇高級/顯示選項->本地資源->本地設備和資源->選中列印機
或者將本機架設成伺服器用遠程伺服器連接本機伺服器列印這個比較麻煩建議采第一種的1和2
第二種：如果遠程伺服器與本地電腦同在一個區域網，可以在遠程伺服器上安裝網路列印機，然後在遠程伺服器上直接列印。
安裝網路列印機的步驟：在遠程伺服器上打開控制面板，找到 添加設備和列印，選擇 添加網路列印機，然後輸入本機（連接列印機的電腦）的IP地址進行搜索。搜索到之後選中列印機，點擊安裝，會在遠程列印機上安裝驅動程序，驅動程序安裝完畢就可以使用網路列印機了

❺ kill-3生成的線程堆棧怎麼查看

第一步：在終端運行Java程序
第二步：通過命令 pidof java 找到已經啟動的java進程的ID，選擇需要查看的java程序的進程ID
第三步：使用命令 kill -3 <java進行的 pid> 列印出java程序的線程堆棧信息
第四步：通常情況下運行的項目可和賣迅能會比較大，那麼這個時候列印的堆棧信息可能會有幾千到幾萬行，為了方便查看，我們往往需要將輸出內容進行重定向
使用linux下的重定向命令方式即可：例如： demo.sh > run.log 2>&1 將輸出信息重定向到 run.log中。
註：在操作系統中，0 1 2分別對應著不同的含義， 如下：
0 ： 標准輸入，即：C中的stdin ， java中的System.in
1 ： 標准輸出， 即：C中的stdout ，java中的配正System.out
2 ： 錯誤輸出， 即：C中的stderr ， java中的System.err

Demo：
----------------------------------------------------------------------------------------------
Sources Code ：
public class PrintThreadTrace {

Object obj1 = new Object();
Object obj2 = new Object();

public void func1(){
synchronized (obj1){
func2();
}
}

public void func2(){
synchronized (obj2){
while(true){
System.out.print("");
}
}
}

public static void main(String[] args){
PrintThreadTrace ptt = new PrintThreadTrace();
ptt.func1();
}
}

----------------------------------------------------------------------------------------------------------------
按照步驟操作後喚此的列印輸出信息：

Full thread mp Java HotSpot(TM) 64-Bit Server VM (24.79-b02 mixed mode):

"Service Thread" daemon prio=10 tid=0x00007fdc880a9000 nid=0x12a4 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE

"C2 CompilerThread1" daemon prio=10 tid=0x00007fdc880a7000 nid=0x12a3 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE

"C2 CompilerThread0" daemon prio=10 tid=0x00007fdc880a4000 nid=0x12a2 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE

"JDWP Command Reader" daemon prio=10 tid=0x00007fdc50001000 nid=0x1299 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE

"JDWP Event Helper Thread" daemon prio=10 tid=0x00007fdc880a1800 nid=0x1298 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE

"JDWP Transport Listener: dt_socket" daemon prio=10 tid=0x00007fdc8809e000 nid=0x1297 runnable [0x0000000000000000]
java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" daemon prio=10 tid=0x00007fdc88091000 nid=0x1296 waiting on condition [0x0000000000000000]
java.lang.Thread.State: RUNNABLE

"Finalizer" daemon prio=10 tid=0x00007fdc88071800 nid=0x1295 in Object.wait() [0x00007fdc77ffe000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000000ecb04858> (a java.lang.ref.ReferenceQueue$Lock)
at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:135)
- locked <0x00000000ecb04858> (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=0x00007fdc8806f800 nid=0x1294 in Object.wait() [0x00007fdc7c10b000]
java.lang.Thread.State: WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
- waiting on <0x00000000ecb04470> (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 <0x00000000ecb04470> (a java.lang.ref.Reference$Lock)

"main" prio=10 tid=0x00007fdc8800b800 nid=0x128e runnable [0x00007fdc8fef7000]
java.lang.Thread.State: RUNNABLE
at com.wenchain.study.PrintThreadTrace.func2(PrintThreadTrace.java:20)
- locked <0x00000000ecc04b20> (a java.lang.Object)
at com.wenchain.study.PrintThreadTrace.func1(PrintThreadTrace.java:13)
- locked <0x00000000ecc04b10> (a java.lang.Object)
at com.wenchain.study.PrintThreadTrace.main(PrintThreadTrace.java:27)

"VM Thread" prio=10 tid=0x00007fdc8806b000 nid=0x1293 runnable

"GC task thread#0 (ParallelGC)" prio=10 tid=0x00007fdc88021000 nid=0x128f runnable

"GC task thread#1 (ParallelGC)" prio=10 tid=0x00007fdc88023000 nid=0x1290 runnable

"GC task thread#2 (ParallelGC)" prio=10 tid=0x00007fdc88024800 nid=0x1291 runnable

"GC task thread#3 (ParallelGC)" prio=10 tid=0x00007fdc88026800 nid=0x1292 runnable

"VM Periodic Task Thread" prio=10 tid=0x00007fdc880b3800 nid=0x12a5 waiting on condition

JNI global references: 1391

Heap
PSYoungGen total 17920K, used 1270K [0x00000000ecb00000, 0x00000000ede80000, 0x0000000100000000)
eden space 15872K, 8% used [0x00000000ecb00000,0x00000000ecc3d898,0x00000000eda80000)
from space 2048K, 0% used [0x00000000edc80000,0x00000000edc80000,0x00000000ede80000)
to space 2048K, 0% used [0x00000000eda80000,0x00000000eda80000,0x00000000edc80000)
ParOldGen total 39424K, used 0K [0x00000000c6200000, 0x00000000c8880000, 0x00000000ecb00000)
object space 39424K, 0% used [0x00000000c6200000,0x00000000c6200000,0x00000000c8880000)
PSPermGen total 21504K, used 2619K [0x00000000c1000000, 0x00000000c2500000, 0x00000000c6200000)
object space 21504K, 12% used [0x00000000c1000000,0x00000000c128edd8,0x00000000c2500000)

----------------------------------------------------------------------------------------------------------------------------
上面的信息中包含了當前JVM中所有運行的線程信息，其中在示例中我們啟動的線程為main線程，其餘的都是JVM自己創建的。
在列印的信息中，我們可以清楚的看見當前線程的調用上下文，可以很清楚的知道程序的運行情況。
並且我們在最後面還能看見當前虛擬機中的內存使用情況，青年世代，老年世代的信息等等...

PS: 在JDK1.5以上，我們可以通過在Java程序中調用Thread.getStackTrace()方法來進行堆棧的自動列印，使得線程堆棧的列印時機可編程控制。
文章知識點與官方知識檔案匹配
Java技能樹首頁概覽
89841 人正在系統學習中
點擊閱讀全文
打開CSDN，閱讀體驗更佳

jstack-查看Java進程的線程堆棧信息,鎖定高消耗資源代碼
jstack主要用來查看某個Java進程內的線程堆棧信息。語法格式如下: jstack[option]pid jstack[option]executable core jstack[option][server-id@]remote-hostname-or-ip 命令行參數選項說明如下: ...
011Java並發包018查看線程堆棧信息_執筆未來的博客
java.util.concurrent.ScheledThreadPoolExecutor$DelayedWorkQueue.take(ScheledThreadPoolExecutor.java:1088) java.util.concurrent.ScheledThreadPoolExecutor$DelayedWorkQueue.take(ScheledThreadPoolExecutor.java:809) java.util.concurre...
最新發布 jstack -- java堆棧常用排查指令
jstack -- java堆棧常用排查指令
繼續訪問

熱門推薦 jstack 命令查看JAVA線程堆棧
JAVA堆棧信息實際生產中，可能由於開發以及測試未能全面覆蓋的代碼質量、性能問題，而引致線程掛起甚至崩潰。可能就需要查看堆棧信息來排查問題了。jps -lvmjps -lvm 用於查看當前機器上運行的java進程。C:\Users\Administrator>jps -lvm 7348 -Dosgi.requiredJavaVersion=1.8 -Dosgi.instance.area.defa
繼續訪問
Java多線程——查看線程堆棧信息
Java多線程——查看線程堆棧信息 摘要：本文主要介紹了查看線程堆棧信息的方法。 使用Thread類的getAllStackTraces()方法 方法定義 可以看到getAllStackTraces()方法的返回值是一個Map對象，key是Thread的實例，value是一個StackTraceElement實例數組： 1 public static Map<Thread, S...
繼續訪問
java堆棧常用排查指令
java 異常排查四板斧 1、查看java 堆棧線程信息 說明 jstack命令列印指定Java進程、核心文件或遠程調試伺服器的Java線程的Java堆棧跟蹤信息。 對於每個Java框架，完整的類名，方法名， 位元組碼索引(BCI)和行號(如果有的話)被列印出來。 使用-m選項，jstack命令列印程序中所有線程的Java和本機幀 計數器(PC)。 對於每個本機幀，當可用時，將列印離PC最近的本機符號。 c++亂碼的名字不會被修改。 要demangle c++名稱，輸出這個 命令可以管道到c++filt。 當
繼續訪問
java診斷工具-Arthas（thread命令）查看當前線程堆棧
cpu使用率與linux 命令top -H -p <pid>的線程CPU類似 1、支持一鍵展示當前最忙的前N個線程並列印堆棧 thread -n 3 沒有線程ID，包含[Internal]表示為JVM內部線程，參考dashboard命令的介紹。 cpuUsage為采樣間隔時間內線程的CPU使用率，與dashboard命令的數據一致。 deltaTime為采樣間隔時間內線程的增量CPU時間，小於1ms時被取整顯示為0ms。 time線程運行總CPU...
繼續訪問

java查看線程的堆棧信息
通過使用jps 命令獲取需要監控的進程的pid，然後使用jstackpid 命令查看線程的堆棧信息。 通過jstack命令可以獲取當前進程的所有線程信息。 每個線程堆中信息中，都可以查看到線程ID、線程的狀態（wait、sleep、running 等狀態）、是否持有鎖信息等。 jstack -l <pid> >jvm_listlocks.txt 轉...
繼續訪問
java 查看線程堆棧信息_Java多線程——查看線程堆棧信息
java多線程——查看線程堆棧信息摘要：本文主要介紹了查看線程堆棧信息的方法。使用thread類的getallstacktraces()方法方法定義可以看到getallstacktraces()方法的返回值是一個map對象，key是thread的實例，value是一個stacktraceelement實例數組：1 public static map getallstacktraces()使用可以使...
繼續訪問
java線程堆棧信息分析
java堆棧信息分析
繼續訪問

java 查看堆棧_javap 命令查看堆棧中信息
javap命令是對.java文件進行反編譯，通過這個命令可以看到堆棧中是怎麼壓棧和出棧的已經執行順序，這里簡單解釋下javap的簡單的使用，下面舉個例子：題目：i++ 和++i的區別解釋：簡單點說 這個問題都不難回答，這里就不說了，但是實際上堆棧中區別也是老大了(這里就用到了javap命令)， 步驟：1.在任意一個盤下面建一個名為Test.java的文件(文件名可以隨意命名)代碼如下：public...
繼續訪問
java 查看線程堆棧信息_jstack-查看Java進程的線程堆棧信息，鎖定高消耗資源代碼。...
jstack主要用來查看某個Java進程內的線程堆棧信息。語法格式如下：jstack[option]pidjstack[option]executablecorejstack[option][server-id@]remote-hostname-or-ip命令行參數選項說明如下：-llonglistings，會列印出額外的鎖信息，在發生死鎖時可以用jstack-lpid來觀察...
繼續訪問
java堆棧信息怎麼看_線程堆棧信息怎麼看？ - cs_person的個人空間 - OSCHINA - 中文開源技術交流社區...
一條線程堆棧信息大概長成下面這個樣子：RMI TCP Connection(267865)-172.16.5.25" daemon prio=10 tid=0x00007fd508371000 nid=0x55ae waiting for monitor entry [0x00007fd4f8684000]java.lang.Thread.State: BLOCKED (on object m...
繼續訪問
線程堆棧信息怎麼看？
一條線程堆棧信息大概長成下面這個樣子： RMI TCP Connection(267865)-172.16.5.25" daemon prio=10 tid=0x00007fd508371000 nid=0x55ae waiting for monitor entry [0x00007fd...
繼續訪問
java的棧和堆
棧與堆都是Java用來在Ram中存放數據的地方。與C++不同，Java自動管理棧和堆，程序員不能直接地設置棧或堆。 Java 的堆是一個運行時數據區,類的(對象從中分配空間。這些對象通過new、newarray、anewarray和multianewarray等指令建立，它們不需要程序代碼來顯式的釋放。堆是由垃圾回收來負責的，堆的優勢是可以動態地分配內存大小，生存期也不必事先告訴編譯器，因為它是在...
繼續訪問
查看java線程_【JAVA】Java線程堆棧信息查看
如何獲得線程的堆棧信息？線上伺服器cpu 100%了，該如何排查問題？1.top命令查詢哪個pid進程佔用cpu高(ps -ef|grep java 獲取PID號)2.通過 top -Hp pid 可以查看該進程下各個線程的cpu使用情況,獲取佔用cpu高的線程id3.執行命令：printf "%X\n" 線程tid(用於獲取佔用cpu高的線程id的16進制數)4.執行命令：jstack pid ...
繼續訪問
kill -3 java_kill -3 PID命令獲取java應用堆棧信息
一、應用場景：當linux伺服器出現異常情況(響應緩慢，負載持續飆升)並且伺服器沒有安裝對應的包而無法使用jstack等命令時，可以使用linux的kill相關命令列印堆棧信息。命令格式：kill -3 PID二、執行步驟：2.1、獲取java進程的PIDps -ef|grep java結果的第二列數字就是進程對應的pid。2.2、kill -3 PID(1)如果項目通過Tomcat進行發布(普通...
繼續訪問
jstack 工具 查看JVM堆棧信息
1|0介紹 jstack是java虛擬機自帶的一種堆棧跟蹤工具。jstack用於列印出給定的java進程ID或corefile或遠程調試服務的Java堆棧信息，如果是在64位機器上，需要指定選項"-J-d64"，Windows的jstack使用方式只支持以下的這種方式： jstack [-l] pid 主要分為兩個功能： a． 針對活著的進程做本地的或遠程的線程mp； b． 針對core文件做線程mp。 jstack用於生成java虛擬機當前時刻的線程快照。線程快照是...
繼續訪問

linux查看java堆棧
1、查看JAVA進程JVM參數 jinfo -flags pid(進程號) -XX:CICompilerCount=2 最大的並行編譯數 -XX:InitialHeapSize=16777216 JVM 的初始堆內存大小 -XX:MaxHeapSize=257949696 JVM 的最大堆內存大小 -XX:MaxNewSize=85983232 -XX:MinHeapDeltaBytes=196608 -XX:NewSize=5570560 -XX:OldSize=11206656 2、JVM 查看.
繼續訪問
Linux 如何查看一個進程的堆棧
有兩種方法：第一種：pstack 進程ID第二種，使用gdb 然後attach 進程ID，然後再使用命令 thread apply all bt 兩種方法都可以列出進程所有的線程的當前的調用棧。不過，使用gdb的方法，還可以查看某些信息，例如局部變數，指針等。不過，如果只看調用棧的話，pstack還是很方便的。
繼續訪問
JAVA獲取堆棧信息
1. 通過Throwable獲取 StackTraceElement[] stackTrace = new Throwable().getStackTrace(); 2. 通過Thread獲取 StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
繼續訪問
java 查看線程棧大小_基於 Java 線程棧的問題排查
除日誌外，還有沒有別的方式跟蹤線上服務問題呢？或者，跟蹤並排除日誌里無法發現的問題？方法當然是有的，就是通過現場快照定位並發現問題。我們所說的現場，主要指這兩方面：Java 線程棧。線程棧是Java線程工作的快照，可以獲得當前線程在做什麼；Java 內存堆。堆是JVM的內存快照，可以獲取內存分配相關信息。

❻ 如何查看java虛擬機堆內存的參數值

請確保java_home/bin配置到path環境變數下，因為這些工具都在jdk的bin目錄下

jps(JVM Process Status Tool)：JVM機進程狀況工具

用來查看基於HotSpot JVM裡面所有進程的具體狀態, 包括進程ID，進程啟動的路徑等等。與unix上的ps類似，用來顯示本地有許可權的java進程，可以查看本地運行著幾個java程序，並顯示他們的進程號。使用jps時，不需要傳遞進程號做為參數。
Jps也可以顯示遠程系統上的JAVA進程，這需要遠程服務上開啟了jstat服務，以及RMI注及服務，不過常用都是對本對的JAVA進程的查看。
命令格式：jps [ options ] [ hostid ]
常用參數說明：
-m 輸出傳遞給main方法的參數，如果是內嵌的JVM則輸出為null。
-l 輸出應用程序主類的完整包名，或者是應用程序JAR文件的完整路徑。
-v 輸出傳給JVM的參數。
例如：
C:\Users\Administrator>jps -lmv
1796 -Dosgi.requiredJavaVersion=1.5 -Xms40m -Xmx512m -XX:MaxPermSize=256m
7340 sun.tools.jps.Jps -lmv -Denv.class.path=.;D:\DevTools\VM\jdk1.6.0_31\\lib\dt.jar;D:\DevTools\VM\jdk1.6.0_31\\lib\tools.jar; -Dapplication.home=D:\DevTools\VM\jdk1.6.0_31 -Xms8m
其中pid為1796的是我的eclipse進程，pid為7340的是jps命令本身的進程

jinfo(Configuration Info for Java)：JVM配置信息工具

可以輸出並修改運行時的java 進程的opts。用處比較簡單，用於輸出JAVA系統參數及命令行參數
命令格式：jinfo [ options ] [ pid ]
常用參數說明：
-flag 輸出，修改，JVM命令行參數
例如：
C:\Users\Administrator>jinfo 1796
將會列印出很多jvm運行時參數信息，由於比較長這里不再列印出來，可以自己試試，內容一目瞭然

Jstack(Stack Trace for Java)：JVM堆棧跟蹤工具
jstack用於列印出給定的java進程ID或core file或遠程調試服務的Java堆棧信息，如果是在64位機器上，需要指定選項"-J-d64「
命令格式：jstack [ option ] pid
常用參數說明：
-F 當』jstack [-l] pid』沒有相應的時候強制列印棧信息
-l 長列表. 列印關於鎖的附加信息,例如屬於java.util.concurrent的ownable synchronizers列表.
-m 列印java和native c/c++框架的所有棧信息.
-h | -help列印幫助信息
例如：
C:\Users\Administrator>jstack 1796
2013-05-22 11:42:38
Full thread mp Java HotSpot(TM) Client VM (20.6-b01 mixed mode):

"Worker-30" prio=6 tid=0x06514c00 nid=0x1018 in Object.wait() [0x056af000]
java.lang.Thread.State: TIMED_WAITING (on object monitor)
at java.lang.Object.wait(Native Method)
at org.eclipse.core.internal.jobs.WorkerPool.sleep(WorkerPool.java:188)
- locked <0x1ad84a90> (a org.eclipse.core.internal.jobs.WorkerPool)
at org.eclipse.core.internal.jobs.WorkerPool.startJob(WorkerPool.java:220)
at org.eclipse.core.internal.jobs.Worker.run(Worker.java:50)
......
......
......
......

jstat(JVM statistics Monitoriing Tool)：JVM統計信息監視工具

對Java應用程序的資源和性能進行實時的命令行的監控，包括了對Heap size和垃圾回收狀況的監控
命令格式：jstat [ option pid [interval [ s | ms ] [count] ] ]
常用參數說明：
-gcutil 輸出已使用空間占總空間的百分比
-gccapacity 輸出堆中各個區域使用到的最大和最小空間
例如：每隔1秒監控jvm內存一次，共監控5次
C:\Users\Administrator>jstat -gccapacity 1796 1s 5
NGCMN NGCMX NGC S0C S1C EC OGCMN OGCMX OGC OC PGCMN PGCMX PGC PC YGC FGC
13632.0 174720.0 40896.0 4032.0 4032.0 32832.0 27328.0 349568.0 81684.0 81684.0 12288.0 262144.0 80640.0 80640.0 42 96
13632.0 174720.0 40896.0 4032.0 4032.0 32832.0 27328.0 349568.0 81684.0 81684.0 12288.0 262144.0 80640.0 80640.0 42 96
13632.0 174720.0 40896.0 4032.0 4032.0 32832.0 27328.0 349568.0 81684.0 81684.0 12288.0 262144.0 80640.0 80640.0 42 96
13632.0 174720.0 40896.0 4032.0 4032.0 32832.0 27328.0 349568.0 81684.0 81684.0 12288.0 262144.0 80640.0 80640.0 42 96
13632.0 174720.0 40896.0 4032.0 4032.0 32832.0 27328.0 349568.0 81684.0 81684.0 12288.0 262144.0 80640.0 80640.0 42 97
C:\Users\Administrator>jstat -gcutil 1796 1s 5
S0 S1 E O P YGC YGCT FGC FGCT GCT
0.00 0.00 0.52 53.35 99.77 42 0.513 99 38.119 38.632
0.00 0.00 0.52 53.35 99.77 42 0.513 99 38.119 38.632
0.00 0.00 0.52 53.35 99.77 42 0.513 99 38.119 38.632
0.00 0.00 0.52 53.35 99.77 42 0.513 99 38.119 38.632
0.00 0.00 0.52 53.35 99.77 42 0.513 99 38.119 38.632
一些術語的中文解釋：
S0C：年輕代中第一個survivor（倖存區）的容量 (位元組)
S1C：年輕代中第二個survivor（倖存區）的容量 (位元組)
S0U：年輕代中第一個survivor（倖存區）目前已使用空間 (位元組)
S1U：年輕代中第二個survivor（倖存區）目前已使用空間 (位元組)
EC：年輕代中Eden（伊甸園）的容量 (位元組)
EU：年輕代中Eden（伊甸園）目前已使用空間 (位元組)
OC：Old代的容量 (位元組)
OU：Old代目前已使用空間 (位元組)
PC：Perm(持久代)的容量 (位元組)
PU：Perm(持久代)目前已使用空間 (位元組)
YGC：從應用程序啟動到采樣時年輕代中gc次數
YGCT：從應用程序啟動到采樣時年輕代中gc所用時間(s)
FGC：從應用程序啟動到采樣時old代(全gc)gc次數
FGCT：從應用程序啟動到采樣時old代(全gc)gc所用時間(s)
GCT：從應用程序啟動到采樣時gc用的總時間(s)
NGCMN：年輕代(young)中初始化(最小)的大小 (位元組)
NGCMX：年輕代(young)的最大容量 (位元組)
NGC：年輕代(young)中當前的容量 (位元組)
OGCMN：old代中初始化(最小)的大小 (位元組)
OGCMX：old代的最大容量 (位元組)
OGC：old代當前新生成的容量 (位元組)
PGCMN：perm代中初始化(最小)的大小 (位元組)
PGCMX：perm代的最大容量 (位元組)
PGC：perm代當前新生成的容量 (位元組)
S0：年輕代中第一個survivor（倖存區）已使用的占當前容量百分比
S1：年輕代中第二個survivor（倖存區）已使用的占當前容量百分比
E：年輕代中Eden（伊甸園）已使用的占當前容量百分比
O：old代已使用的占當前容量百分比
P：perm代已使用的占當前容量百分比
S0CMX：年輕代中第一個survivor（倖存區）的最大容量 (位元組)
S1CMX ：年輕代中第二個survivor（倖存區）的最大容量 (位元組)
ECMX：年輕代中Eden（伊甸園）的最大容量 (位元組)
DSS：當前需要survivor（倖存區）的容量 (位元組)（Eden區已滿）
TT： 持有次數限制
MTT ： 最大持有次數限制

jmap( Memory Map for Java)：JVM內存映像工具

列印出某個java進程（使用pid）內存內的所有『對象』的情況（如：產生那些對象，及其數量）
命令格式：jmap [ option ] pid
常用參數說明：
-mp:[live,]format=b,file=<filename> 使用二進制形式輸出jvm的heap內容到文件中， live子選項是可選的，假如指定live選項,那麼只輸出活的對象到文件.
-histo[:live] 列印每個class的實例數目,內存佔用,類全名信息. VM的內部類名字開頭會加上前綴」*」. 如果live子參數加上後,只統計活的對象數量.
-F 強迫.在pid沒有相應的時候使用-mp或者-histo參數. 在這個模式下,live子參數無效.
例如：以二進制形式輸入當前堆內存映像到文件data.hprof中
jmap -mp:live,format=b,file=data.hprof 1796
生成的文件可以使用jhat工具進行分析，在OOM（內存溢出）時，分析大對象，非常有用
通過使用如下參數啟動JVM，也可以獲取到mp文件：
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=./java_pid<pid>.hprof
在jvm發生內存溢出時生成內存映像文件

jhat(JVM Heap Analysis Tool)：JVM堆轉儲快照分析工具

用於對JAVA heap進行離線分析的工具，他可以對不同虛擬機中導出的heap信息文件進行分析，如LINUX上導出的文件可以拿到WINDOWS上進行分析，可以查找諸如內存方面的問題。
命令格式：jhat mpfile(jmap生成的文件)
例如：分析jmap導出的內存映像
jhat data.hprof
執行成功後，訪問http://localhost:7000即可查看內存信息，

MAT(Memory Analyzer Tool)：一個基於Eclipse的內存分析工具

官網： http://www.eclipse.org/mat/
update：http://download.eclipse.org/mat/1.2/update-site/
這是eclipse的一個插件，安裝後可以打開xxx.hprof文件，進行分析，比jhat更方便使用，有些時候由於線上xxx.hprof文件過大，直接使用jhat進行初步分析了，可以的話拷貝到本地分析效果更佳。

圖形化監控工具：

在JDK安裝目錄bin下面有兩個可視化監控工具
1. JConsole(Java Monitoring and Management Console) 基於JMX的可視化管理工具。
2. VisualVM(All-in-one Java Troubleshooting Tool)隨JDK發布的最強大的運行監視和故障處理程序。
推薦使用VisualVM，他有很多插件，可以更方便的監控運行時JVM

❼ 手機調試Android程序出異常時不列印堆棧信息

列印堆棧是調試的常用方法，一般在系統異常時，我們可以將異常情況下的堆棧列印出來，這樣十分方便錯誤查找。實際上還有另外一個非常有用的功能：分析代碼的行為。android代碼太過龐大復雜了，完全的靜態分析經常是無從下手，因此通過列印堆棧的動態分析也十分必要。

Android列印堆棧的方法，簡單歸類一下
1. zygote的堆棧mp
實際上這個可以同時mp java線程及native線程的堆棧，對於java線程，java堆棧和native堆棧都可以得到。
使用方法很簡單，直接在adb shell或串口中輸入：
[plain] view plain
kill -3 <pid>
輸出的trace會保存在 /data/anr/traces.txt文件中。這個需要注意，如果沒有 /data/anr/這個目錄或/data/anr/traces.txt這個文件，需要手工創建一下，並設置好讀寫許可權。
如果需要在代碼中，更容易控制堆棧的輸出時機，可以用以下命令獲取zygote的core mp:
[java] view plain
Process.sendSignal(pid, Process.SIGNAL_QUIT);
原理和命令行是一樣的。
不過需要注意兩點：
adb shell可能會沒有許可權，需要root。
android 4.2中關閉了native thread的堆棧列印，詳見 dalvik/vm/Thread.cpp的mpNativeThread方法：
[cpp] view plain
dvmPrintDebugMessage(target,
"\"%s\" sysTid=%d nice=%d sched=%d/%d cgrp=%s\n",
name, tid, getpriority(PRIO_PROCESS, tid),
schedStats.policy, schedStats.priority, schedStats.group);
mpSchedStat(target, tid);
// Temporarily disabled collecting native stacks from non-Dalvik
// threads because sometimes they misbehave.
//dvmDumpNativeStack(target, tid);
Native堆棧的列印被關掉了！不過對於大多數情況，可以直接將這個注釋打開。

2. debuggerd的堆棧mp
debuggerd是android的一個daemon進程，負責在進程異常出錯時，將進程的運行時信息mp出來供分析。debuggerd生 成的coremp數據是以文本形式呈現，被保存在 /data/tombstone/ 目錄下(名字取的也很形象，tombstone是墓碑的意思)，共可保存10個文件，當超過10個時，會覆蓋重寫最早生成的文件。從4.2版本開 始，debuggerd同時也是一個實用工具：可以在不中斷進程執行的情況下列印當前進程的native堆棧。使用方法是:
[plain] view plain
debuggerd -b <pid>
這可以協助我們分析進程執行行為，但最最有用的地方是：它可以非常簡單的定位到native進程中鎖死或錯誤邏輯引起的死循環的代碼位置。

3. java代碼中列印堆棧
Java代碼列印堆棧比較簡單， 堆棧信息獲取和輸出，都可以通過Throwable類的方法實現。目前通用的做法是在java進程出現需要注意的異常時，列印堆棧，然後再決定退出或挽救。通常的方法是使用exception的printStackTrace()方法：
[java] view plain
try {
...
} catch (RemoteException e) {
e.printStackTrace();
...
}
當然也可以只列印堆棧不退出，這樣就比較方便分析代碼的動態運行情況。Java代碼中插入堆棧列印的方法如下：
[java] view plain
Log.d(TAG,Log.getStackTraceString(new Throwable()));

4. C++代碼中列印堆棧
C++也是支持異常處理的，異常處理庫中，已經包含了獲取backtrace的介面，Android也是利用這個介面來列印堆棧信息的。在Android的C++中，已經集成了一個工具類CallStack，在libutils.so中。使用方法：
[cpp] view plain
#include <utils/CallStack.h>
...
CallStack stack;
stack.update();
stack.mp();
使用方式比較簡單。目前Andoid4.2版本已經將相關信息解析的很到位，符號表查找，demangle，偏移位置校正都做好了。
[plain] view plain

5. C代碼中列印堆棧
C代碼，尤其是底層C庫，想要看到調用的堆棧信息，還是比較麻煩的。 CallStack肯定是不能用，一是因為其實C++寫的，需要重新封裝才能在C中使用，二是底層庫反調上層庫的函數，會造成鏈接器循環依賴而無法鏈接。 不過也不是沒有辦法，可以通過android工具類CallStack實現中使用的unwind調用及符號解析函數來處理。
這里需要注意的是，為解決鏈接問題，最好使用dlopen方式，查找需要用到的介面再直接調用，這樣會比較簡單。如下為相關的實現代碼，只需要在要 列印的文件中插入此部分代碼，然後調用getCallStack()即可，無需包含太多的頭文件和修改Android.mk文件：
[cpp] view plain
#define MAX_DEPTH 31
#define MAX_BACKTRACE_LINE_LENGTH 800
#define PATH "/system/lib/libcorkscrew.so"

typedef ssize_t (*unwindFn)(backtrace_frame_t*, size_t, size_t);
typedef void (*unwindSymbFn)(const backtrace_frame_t*, size_t, backtrace_symbol_t*);
typedef void (*unwindSymbFreeFn)(backtrace_symbol_t*, size_t);

static void *gHandle = NULL;

static int getCallStack(void){
ssize_t i = 0;
ssize_t result = 0;
ssize_t count;
backtrace_frame_t mStack[MAX_DEPTH];
backtrace_symbol_t symbols[MAX_DEPTH];

unwindFn unwind_backtrace = NULL;
unwindSymbFn get_backtrace_symbols = NULL;
unwindSymbFreeFn free_backtrace_symbols = NULL;

// open the so.
if(gHandle == NULL) gHandle = dlopen(PATH, RTLD_NOW);

// get the interface for unwind and symbol analyse
if(gHandle != NULL) unwind_backtrace = (unwindFn)dlsym(gHandle, "unwind_backtrace");
if(gHandle != NULL) get_backtrace_symbols = (unwindSymbFn)dlsym(gHandle, "get_backtrace_symbols");
if(gHandle != NULL) free_backtrace_symbols = (unwindSymbFreeFn)dlsym(gHandle, "free_backtrace_symbols");

if(!gHandle ||!unwind_backtrace ||!get_backtrace_symbols || !free_backtrace_symbols ){
ALOGE("Error! cannot get unwind info: handle:%p %p %p %p",
gHandle, unwind_backtrace, get_backtrace_symbols, free_backtrace_symbols );
return result;
}

count= unwind_backtrace(mStack, 1, MAX_DEPTH);
get_backtrace_symbols(mStack, count, symbols);

for (i = 0; i < count; i++) {
char line[MAX_BACKTRACE_LINE_LENGTH];

const char* mapName = symbols[i].map_name ? symbols[i].map_name : "<unknown>";
const char* symbolName =symbols[i].demangled_name ? symbols[i].demangled_name : symbols[i].symbol_name;
size_t fieldWidth = (MAX_BACKTRACE_LINE_LENGTH - 80) / 2;

if (symbolName) {
uint32_t pc_offset = symbols[i].relative_pc - symbols[i].relative_symbol_addr;
if (pc_offset) {
snprintf(line, MAX_BACKTRACE_LINE_LENGTH, "#%02d pc %08x %.*s (%.*s+%u)",
i, symbols[i].relative_pc, fieldWidth, mapName,
fieldWidth, symbolName, pc_offset);
} else {
snprintf(line, MAX_BACKTRACE_LINE_LENGTH, "#%02d pc %08x %.*s (%.*s)",
i, symbols[i].relative_pc, fieldWidth, mapName,
fieldWidth, symbolName);
}
} else {
snprintf(line, MAX_BACKTRACE_LINE_LENGTH, "#%02d pc %08x %.*s",
i, symbols[i].relative_pc, fieldWidth, mapName);
}

ALOGD("%s", line);
}

free_backtrace_symbols(symbols, count);

return result;
}
對sched_policy.c的堆棧調用分析如下,注意具體是否要列印，在哪裡列印，還可以通過pid、uid、property等來控制一下，這樣就不會被淹死在trace的汪洋大海中。
[plain] view plain
D/SchedPolicy( 1350): #00 pc 0000676c /system/lib/libcutils.so
D/SchedPolicy( 1350): #01 pc 00006b3a /system/lib/libcutils.so (set_sched_policy+49)
D/SchedPolicy( 1350): #02 pc 00010e82 /system/lib/libutils.so (androidSetThreadPriority+61)
D/SchedPolicy( 1350): #03 pc 00068104 /system/lib/libandroid_runtime.so (android_os_Process_setThreadPriority(_JNIEnv*, _jobject*, int, int)+7)
D/SchedPolicy( 1350): #04 pc 0001e510 /system/lib/libdvm.so (dvmPlatformInvoke+112)
D/SchedPolicy( 1350): #05 pc 0004d6aa /system/lib/libdvm.so (dvmCallJNIMethod(unsigned int const*, JValue*, Method const*, Thread*)+417)
D/SchedPolicy( 1350): #06 pc 00027920 /system/lib/libdvm.so
D/SchedPolicy( 1350): #07 pc 0002b7fc /system/lib/libdvm.so (dvmInterpret(Thread*, Method const*, JValue*)+184)
D/SchedPolicy( 1350): #08 pc 00060c30 /system/lib/libdvm.so (dvmCallMethodV(Thread*, Method const*, Object*, bool, JValue*, std::__va_list)+271)
D/SchedPolicy( 1350): #09 pc 0004cd34 /system/lib/libdvm.so
D/SchedPolicy( 1350): #10 pc 00049382 /system/lib/libandroid_runtime.so
D/SchedPolicy( 1350): #11 pc 00065e52 /system/lib/libandroid_runtime.so
D/SchedPolicy( 1350): #12 pc 0001435e /system/lib/libbinder.so (android::BBinder::transact(unsigned int, android::Parcel const&, android::Parcel*, unsigned int)+57)
D/SchedPolicy( 1350): #13 pc 00016f5a /system/lib/libbinder.so (android::IPCThreadState::executeCommand(int)+513)
D/SchedPolicy( 1350): #14 pc 00017380 /system/lib/libbinder.so (android::IPCThreadState::joinThreadPool(bool)+183)
D/SchedPolicy( 1350): #15 pc 0001b160 /system/lib/libbinder.so
D/SchedPolicy( 1350): #16 pc 00011264 /system/lib/libutils.so (android::Thread::_threadLoop(void*)+111)
D/SchedPolicy( 1350): #17 pc 000469bc /system/lib/libandroid_runtime.so (android::AndroidRuntime::javaThreadShell(void*)+63)
D/SchedPolicy( 1350): #18 pc 00010dca /system/lib/libutils.so
D/SchedPolicy( 1350): #19 pc 0000e3d8 /system/lib/libc.so (__thread_entry+72)
D/SchedPolicy( 1350): #20 pc 0000dac4 /system/lib/libc.so (pthread_create+160)
D/SchedPolicy( 1350): #00 pc 0000676c /system/lib/libcutils.so
D/SchedPolicy( 1350): #01 pc 00006b3a /system/lib/libcutils.so (set_sched_policy+49)
D/SchedPolicy( 1350): #02 pc 00016f26 /system/lib/libbinder.so (android::IPCThreadState::executeCommand(int)+461)
D/SchedPolicy( 1350): #03 pc 00017380 /system/lib/libbinder.so (android::IPCThreadState::joinThreadPool(bool)+183)
D/SchedPolicy( 1350): #04 pc 0001b160 /system/lib/libbinder.so
D/SchedPolicy( 1350): #05 pc 00011264 /system/lib/libutils.so (android::Thread::_threadLoop(void*)+111)
D/SchedPolicy( 1350): #06 pc 000469bc /system/lib/libandroid_runtime.so (android::AndroidRuntime::javaThreadShell(void*)+63)
D/SchedPolicy( 1350): #07 pc 00010dca /system/lib/libutils.so
D/SchedPolicy( 1350): #08 pc 0000e3d8 /system/lib/libc.so (__thread_entry+72)
D/SchedPolicy( 1350): #09 pc 0000dac4 /system/lib/libc.so (pthread_create+160)

6. 其它堆棧信息查詢