2. 程式人生 > >記一次 JVM 原始碼分析(5.異常處理)

記一次 JVM 原始碼分析(5.異常處理)

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

異常列印

Java 如果發生異常，通常會呼叫 Throwable.printStackTrace 去列印堆疊資訊。 堆疊資訊包括完整類名，方法名，java 檔名，行號 而這樣的資訊根據發生 Crash 執行緒所經歷的n個方法會打印出n行。 整個過程被稱為棧回朔

棧回朔

棧回朔的過程發生於異常被 New 出來的時候

Throwable.backtrace 這個 Throwbale 的成員變數就是用來儲存棧回朔連結串列的

 /**
     * WARNING: this must be the second variable. Native code saves some
     * indication of the stack backtrace in this slot.
     */
 

    private transient Object backtrace = buildStackElement();//

	private native StackTraceElement buildStackElement();

可見 Throwable 初始化的時候會呼叫 native 方法 buildStackElement() StackTraceElement

public class StackTraceElement {

    private String declaringClass;
    private String methodName;
    private
 
 String fileName;
    private int lineNumber;
    
    StackTraceElement parent;
	.......
}

buildStackElement()

s32 java_io_Throwable_buildStackElement(Runtime *runtime, JClass *clazz) {
    RuntimeStack *stack = runtime->stack;
    Instance *tmps = (Instance *) localvar_getRefer(runtime->localvar,
 
 0);
#if _JVM_DEBUG_BYTECODE_DETAIL > 5
    invoke_deepth(runtime);
    jvm_printf("java_io_Throwable_buildStackElement %s \n", utf8_cstr(tmps->mb.clazz->name));
#endif
    Instance *ins = buildStackElement(runtime, runtime->parent);
    push_ref(stack, ins);
    return 0;
}

這裡從運算元棧中取出當前 Throwbale 物件，runtime 是當前棧幀即呼叫 buildStackElement() 的棧幀，所以回朔開始應該是上一個棧幀。

//生成堆疊元素物件 StackTraceElement
Instance *buildStackElement(Runtime *runtime, Runtime *target) {
    JClass *clazz = classes_load_get_c(STR_CLASS_JAVA_LANG_STACKTRACE, target);
    if (clazz) {
        Instance *ins = instance_create(runtime, clazz);
        gc_refer_hold(ins);
        instance_init(ins, runtime);
        c8 *ptr;
        //方法所在類
        ptr = getFieldPtr_byName_c(ins, STR_CLASS_JAVA_LANG_STACKTRACE, "declaringClass", STR_INS_JAVA_LANG_STRING, runtime);
        if (ptr) {
            Instance *name = jstring_create(target->clazz->name, runtime);
            setFieldRefer(ptr, name);
        }
        //呼叫的方法名
        ptr = getFieldPtr_byName_c(ins, STR_CLASS_JAVA_LANG_STACKTRACE, "methodName", STR_INS_JAVA_LANG_STRING, runtime);
        if (ptr) {
            Instance *name = jstring_create(target->method->name, runtime);
            setFieldRefer(ptr, name);
        }
        //java 原始檔名
        ptr = getFieldPtr_byName_c(ins, STR_CLASS_JAVA_LANG_STACKTRACE, "fileName", STR_INS_JAVA_LANG_STRING, runtime);
        if (ptr) {
            Instance *name = jstring_create(target->clazz->source, runtime);
            setFieldRefer(ptr, name);
        }
        //程式碼所在行號
        ptr = getFieldPtr_byName_c(ins, STR_CLASS_JAVA_LANG_STACKTRACE, "lineNumber", "I", runtime);
        if (ptr) {
            if (target->method->access_flags & ACC_NATIVE) {
                setFieldInt(ptr, -1);
            } else {
                setFieldInt(ptr, getLineNumByIndex(target->ca, (s32) (target->pc - target->ca->code)));
            }
        }
        //遞迴，如果還有父方法棧則遞迴生成父方法棧資訊
        if (target->parent && target->parent->parent) {
            ptr = getFieldPtr_byName_c(ins, STR_CLASS_JAVA_LANG_STACKTRACE, "parent", "Ljava/lang/StackTraceElement;", runtime);
            if (ptr) {
                Instance *parent = buildStackElement(runtime, target->parent);
                setFieldRefer(ptr, parent);
            }
        }
        gc_refer_release(ins);
        return ins;
    }
    return NULL;
}
  • new StackTraceElement 並且向內部填充棧幀資訊(類名，原始碼名，方法名，行號)
  • 遞迴生成夫棧幀的 StackTraceElement

列印棧回朔資訊

那麼當呼叫 printStacktrace 的時候就很簡單了。

  • Java 層實現
public void printStackTrace(Writer writer) {
        try {
            writer.write(getCodeStack());
        } catch (IOException ex) {
        }

    }
    public String getCodeStack() {
        StringBuilder stack = new StringBuilder();
        String msg = getMessage();
        stack.append(this.getClass().getName()).append(": ").append(msg == null ? "" : msg).append("\n");
        if (backtrace != null) {
            StackTraceElement sf = (StackTraceElement) backtrace;
            while (sf != null) {
                try {
                    Class clazz = Class.forName(sf.getDeclaringClass());
                    if (!clazz.isAssignableFrom(Throwable.class)) {
                        stack.append("    at ").append(sf.getDeclaringClass());
                        stack.append(".").append(sf.getMethodName());
                        stack.append("(").append(sf.getFileName());
                        stack.append(":").append(sf.getLineNumber());
                        stack.append(")\n");
                    }
                    sf = sf.parent;
                } catch (Exception e) {
                }
            }
        }
        return stack.toString();
    }
  • Native
//列印異常
void print_exception(Runtime *runtime) {
    __refer ref = pop_ref(runtime->stack);
    Instance *ins = (Instance *) ref;
    Utf8String *getStackFrame_name = utf8_create_c("getCodeStack");
    Utf8String *getStackFrame_type = utf8_create_c("()Ljava/lang/String;");
    MethodInfo *getStackFrame = find_methodInfo_by_name(ins->mb.clazz->name, getStackFrame_name,
                                                        getStackFrame_type, runtime);
    utf8_destory(getStackFrame_name);
    utf8_destory(getStackFrame_type);
    if (getStackFrame) {
        push_ref(runtime->stack, ins);
        s32 ret = execute_method_impl(getStackFrame, runtime, getStackFrame->_this_class);
        if (ret != RUNTIME_STATUS_NORMAL) {
            ins = pop_ref(runtime->stack);
            return;
        }
        ins = (Instance *) pop_ref(runtime->stack);
        Utf8String *str = utf8_create();
        jstring_2_utf8(ins, str);
        printf("%s\n", utf8_cstr(str));
        utf8_destory(str);
    } else {
        printf("ERROR: %s\n", utf8_cstr(ins->mb.clazz->name));
    }
}

異常丟擲

異常產生

  • 虛擬機器執行時，內部發出的異常，如沒有搜尋到某方法，稱為虛擬機器內部異常
  • 在 Java 程式碼中使用 throw 丟擲的異常

虛擬機器內部異常 如下 Class.forName 如果沒有找到對應的 Class 則從虛擬機器內部丟擲 ClassNotFoundException 丟擲流程一般是：

  • New 出內部異常的例項
  • 返回值設為 RUNTIME_STATUS_EXCEPTION，通知直譯器下一步跳轉到異常處理 Handler
s32 java_lang_Class_forName(Runtime *runtime, JClass *clazz) {
    RuntimeStack *stack = runtime->stack;
    Instance *jstr = (Instance *) localvar_getRefer(runtime->localvar, 0);
    JClass *cl = NULL;
    s32 ret = RUNTIME_STATUS_NORMAL;
    if (jstr) {
       ......
       cl = classes_load_get(ustr, runtime);
        if (!cl) {
            Instance *exception = exception_create(JVM_EXCEPTION_CLASSNOTFOUND, runtime);
            push_ref(stack, (__refer) exception);
            ret = RUNTIME_STATUS_EXCEPTION;
        } else {
            .....
        }
    } else {
        Instance *exception = exception_create(JVM_EXCEPTION_NULLPOINTER, runtime);
        push_ref(stack, (__refer) exception);
        ret = RUNTIME_STATUS_EXCEPTION;
    }
    .....
    return ret;
}

Java 中丟擲異常

  • 運算元棧中取出目標異常的物件並推入本地變數
  • 返回值設為 RUNTIME_STATUS_EXCEPTION，通知直譯器下一步跳轉到異常處理 Handler
case op_athrow: {
                        Instance *ins = (Instance *) pop_ref(stack);
                        push_ref(stack, (__refer) ins);

#if _JVM_DEBUG_BYTECODE_DETAIL > 5
                        invoke_deepth(runtime);
                    jvm_printf("athrow  [%llx].exception throws  \n", (s64)(intptr_t)ins);
#endif
                        //opCode +=  1;
                        ret = RUNTIME_STATUS_EXCEPTION;
                        break;
                    }

異常處理

在 Switch 直譯器取指令迴圈體的末尾，如果判斷到上一次指令執行的返回值 ret == RUNTIME_STATUS_EXCEPTION，則代表現在需要進入異常分發的流程。

  • 迴圈對比 Code 屬性中的異常向量表，如果 catch 的型別符合丟擲異常的型別的話，則進入該分支
else if (ret == RUNTIME_STATUS_EXCEPTION) {
                    //取出目標異常物件
                    Instance *ins = pop_ref(stack);
                    //jvm_printf("stack size:%d , enter size:%d\n", stack->size, stackSize);
                    //restore stack enter method size, must pop for garbage
                    while (stack->size > stackSize)pop_empty(stack);
                    push_ref(stack, ins);

                    //                    if (utf8_equals_c(ins->mb.clazz->name, "espresso/util/NotConstant")) {
                    //                        int debug = 1;
                    //                    }

#if _JVM_DEBUG_BYTECODE_DETAIL > 3
                    s32 lineNum = getLineNumByIndex(ca, runtime->pc - ca->code);
                    printf("   at %s.%s(%s.java:%d)\n",
                        utf8_cstr(clazz->name), utf8_cstr(method->name),
                        utf8_cstr(clazz->name),
                        lineNum
                    );
#endif
                    //從異常向量表中找到合適的異常 Handler，即對應的 catch 分支
                    ExceptionTable *et = _find_exception_handler(runtime, ins, ca, (s32) (opCode - ca->code), ins);
                    if (et == NULL) {
                        break;
                    } else {
#if _JVM_DEBUG_BYTECODE_DETAIL > 3
                        jvm_printf("Exception : %s\n", utf8_cstr(ins->mb.clazz->name));
#endif
                        //跳轉到合適的分支
                        opCode = (ca->code + et->handler_pc);
                        ret = RUNTIME_STATUS_NORMAL;
                    }
                }

static ExceptionTable *
_find_exception_handler(Runtime *runtime, Instance *exception, CodeAttribute *ca, s32 offset, __refer exception_ref) {
    Instance *ins = (Instance *) exception_ref;

    s32 i;
    ExceptionTable *e = ca->exception_table;
    for (i = 0; i < ca->exception_table_length; i++) {

        if (offset >= (e + i)->start_pc
            && offset <= (e + i)->end_pc) {
            if (!(e + i)->catch_type) {
                return e + i;
            }
            ConstantClassRef *ccr = class_get_constant_classref(runtime->clazz, (e + i)->catch_type);
            JClass *catchClass = classes_load_get(ccr->name, runtime);
            //catch 型別和丟擲型別對比
            if (instance_of(catchClass, exception, runtime))
                return e + i;
        }
    }
    return NULL;
}

關於 finally 塊 finally 塊在位元組碼中並沒有什麼特殊的標誌，正常來說它會緊跟在 try 塊之後， try 完，catch 塊處理完就會走到 finally 塊。如果 try 塊中含有 return，則 return 指令會被編譯器放到 finally 後面，需要注意的是 retrun 的返回值，在 try 塊末尾就回被儲存起來準備返回，finally 塊的修改不會改變返回值

相關推薦

記一次 JVM 原始碼分析(5.異常處理)

異常列印 Java 如果發生異常，通常會呼叫 Throwable.printStackTrace 去列印堆疊資訊。 堆疊資訊包括完整類名，方法名，java 檔名，行號 而這樣的資訊根據發生 Crash 執行緒所經歷的n個方法會打印出n行。 整個過程被稱為棧回朔

記一次 JVM 原始碼分析(3.記憶體管理與GC)

簡介 miniJVM 的記憶體管理的實現較為簡單 記憶體分配使用了開源的 ltalloc 庫 GC就是經典的 Mark-Sweep GC 物件分配 物件分配要關注的就兩個過程 New 一個 Java 物件的過程 記憶體塊在堆上分配的過程 物件在 JVM

記一次 JVM 原始碼分析(4.直譯器與方法執行)

簡介 miniJVM 作為一個 mini 的 Java VM，實現了 Switch 直譯器，並不支援主流 JVM 的 JIT 或者更為複雜的 AOT。但這樣對於我們瞭解位元組碼的執行已經足夠了。 位元組碼指令 基於堆疊 位元組碼指令類似於彙編指令，但是不同的是：

記一次socket_create()函數耗時異常記錄

des inpu 100% 可能 應用程序 解釋 一次 urn 異常 背景： 下午開發時突然整個頁面耗時增加，空接口每次都需要2-3秒的耗時，一開始以為連開發環境數據庫出現問題，最後斷開數據庫跑，發現還是很慢 最終逐步調試此頁面耗時，定位到了socket_c

記一次JVM Metaspace溢出排查

jvm參數 oom task visualvm map 排除 創建 thread 類裝載 多圖預警！ 環境：系統測試(Windows Server/JRE8/tomcat7) 現象：應用運行幾天後，出現訪問超時，服務器cpu利用率居高不下 問題日誌：OutOfMemory

記一次網上流量分析題

words itl word 很多 release sctf 數據包 base 沒有 這是捕獲的黑客攻擊數據包，LateRain用戶的密碼在此次攻擊中泄露了，你能找到嗎？ FLAG格式：SCTF{LateRain的明文密碼} LINK: http://pan.baidu.c

記一次Linux系統安裝的異常（AMI配置）

pos 網卡配置 software blog let 一次 war win 版本 一、背景 安裝Linux系統（Debian 8.8），老是失敗，卡在Install Software （12%的位置） 二、解決？ 網上搜到的解決方法 1. 安裝過程中不要拔網線（我沒拔）

記一次vCenter轉移CentOS6.5至workstation的網卡問題

CentOS6.5 網卡從vCenter導出CentOS6.5的OVF模板，在本機導入OVF模板啟動正常，開機後發現網卡不見了，啟動網卡服務系統提示Bringing up interface eth0： Device eth0 does not seem to be present，delaying init

記一次源碼分析

環境 space () esp clu pac 返回對象 對象 單步調試 首先分析一段很短的代碼 #include<iostream> #include<vector> using namespace std; vector<int>

dubbo的一次請求原始碼分析

呼叫某個服務首先會進入到動態代理。 InvokerInvocationHandler#invoke(Object proxy, Method method, Object[] args) public Object invoke(Object proxy, Method method,

解Bug之路——記一次JVM堆外記憶體洩露Bug的查詢

前言JVM的堆外記憶體洩露的定位一直是個比較棘手的問題。此次的Bug查詢從堆內記憶體的洩露反推出堆外記憶體，同時對實體記憶體的使用做了定量的分析，從而實錘了Bug的源頭。筆者將此Bug分析的過程寫成部落格，以饗讀者。由於實體記憶體定量分析部分用到了linux kernel虛擬

linux程序和執行緒排查 · 記一次JVM CPU高負載的排查辦法

前言通過本文，你將學會：1、linux上程序及程序中執行緒排查的基本方法，如檢視程序中的執行緒數此文中的執行緒一般指輕量級程序。檢視所有程序資訊 top -H 加上-H這個選項啟動top，top一行顯示一個執行緒（指的是（輕量級）程序？ ）。否則，它一行顯示一個程序。先輸入

記一次spring5原始碼完整編譯過程

學習java已有3年之久，spring一直停留在應用階段，兩次面試阿里的經歷讓我深感學習spring原始碼的重要性，廢話不多說，開搞！ 1、環境： jdk1.8+spring5+gradle4.7+eclipse4.6 如果要參考該教程，環境最好一樣（eclipse除外

記一次ThinkPHP原始碼審計

一、寫在前面 週末閒得蛋疼，審了一套朋友給的系統，過程挺有意思的，開始的時候覺得基於TP3.0二次開發的系統應該是蠻簡單的，畢竟TP爆了很多漏洞。後來發現開發做了不少安全措施。因此記錄一下這次審計，當時自己學習的記錄吧。 二、後臺注入 最開始的時候，因為快吃飯了，就用RIPS掃了掃(事實證明，沒有什麼毛用)

記一次mariadb 安裝 出現scok異常

當安裝資料庫Maria時,使用yum install mariadb*. systemctl start mariadb 會提示 /var/lib/mysql 目錄已經初始化了, 但是當後面用到的時

記一次JVM調優（Permanent Generation）

最近在一次搭建公司系統執行環境的時候tomcat總是報出 java.lang.OutOfMemoryError PermGen space 的問題，即記憶體溢位 在解決這個問題的時候 一.問題解決 此處用到一個命令：jmap 顯示java堆中的詳

記一次jvm crash

昨天下午4：30，系統發生了有史以來最刺激的崩潰，一開始是２臺掛了（線上共５臺），這個基本上很少見，一般情況下都是偶爾一臺掛掉。趕緊手動重啟，搞笑的是重啟起來的機器裡馬也掛了，結果就出現了一種尷尬的局面，我們不停的重啟，機器不斷地報警，不斷地掛，整個過程持續了20多分鐘。其實

記一次線上mysql主從架構異常的恢復經歷

fault ase 主從數據庫 sta start 1-1 href show color 前提：之前一位同事負責的一位客戶，因後期轉到devops小組。所以將此用戶交接給我，在後期發現有一套數據庫主從環境，從庫已經無法正常使用。查看slave 狀態為： 其中:Master

解Bug之路-記一次JVM堆外記憶體洩露Bug的查詢

# 解Bug之路-記一次JVM堆外記憶體洩露Bug的查詢 ## 前言 JVM的堆外記憶體洩露的定位一直是個比較棘手的問題。此次的Bug查詢從堆內記憶體的洩露反推出堆外記憶體，同時對實體記憶體的使用做了定量的分析，從而實錘了Bug的源頭。筆者將此Bug分析的過程寫成部落格，以饗讀者。 由於實體記憶體定量分

記一次服務器IO過高處理過程

linux 服務器 緩沖區 io負載 記一次服務器IO過高處理過程 一、背景 在一次上線升級後，發現兩臺tomcat服務器的IOwait一直超過100ms，高峰時甚至超過300ms，檢查服務器發現CPU負載，內存的使用率都不高。問題可能出現在硬盤讀寫，而且那塊硬盤除了寫日誌外，沒有其他