Throwable源码分析

最新推荐文章于 2022-05-30 14:59:49 发布
最新推荐文章于 2022-05-30 14:59:49 发布
阅读量388 收藏
点赞数
分类专栏： 源码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26896085/article/details/102719651
版权 
package java.lang;
import  java.io.*;
import  java.util.*;


// 
public class Throwable implements Serializable {
    // 
    private static final long serialVersionUID = -3042686055658047285L;
    // 用transient关键字标记的成员变量不参与序列化过程。
    private transient Object backtrace;
    // 存储信息
    private String detailMessage;
    
    private static class SentinelHolder {
        public static final StackTraceElement STACK_TRACE_ELEMENT_SENTINEL =
            new StackTraceElement("", "", null, Integer.MIN_VALUE);
        public static final StackTraceElement[] STACK_TRACE_SENTINEL =
            new StackTraceElement[] {STACK_TRACE_ELEMENT_SENTINEL};
    }
    private static final StackTraceElement[] UNASSIGNED_STACK = new StackTraceElement[0];
    // 存储Throwable信息
    private Throwable cause = this;
    private StackTraceElement[] stackTrace = UNASSIGNED_STACK;
    // 用来存储被抑制的异常
    private static final List<Throwable> SUPPRESSED_SENTINEL =
        Collections.unmodifiableList(new ArrayList<Throwable>(0));
    // 抑制的异常，SUPPRESSED_SENTINEL为static final， 而suppressedExceptions可以改变
    private List<Throwable> suppressedExceptions = SUPPRESSED_SENTINEL;
    // 定义几个字段，异常输出时进行拼接。
    private static final String NULL_CAUSE_MESSAGE = "Cannot suppress a null exception.";
    private static final String SELF_SUPPRESSION_MESSAGE = "Self-suppression not permitted";
    private static final String CAUSE_CAPTION = "Caused by: ";
    private static final String SUPPRESSED_CAPTION = "Suppressed: ";
    
    // 构造函数
    public Throwable() {
        // 堆栈信息跟踪
        fillInStackTrace();
    }
    
    // 构造函数
    public Throwable(String message) {
        // 堆栈信息跟踪
        fillInStackTrace();
        // 记录的信息
        detailMessage = message;
    }
    
    // 构造函数
    public Throwable(String message, Throwable cause) {
        // 堆栈信息跟踪
        fillInStackTrace();
        detailMessage = message;
        this.cause = cause;
    }
    
    // 构造函数
    public Throwable(Throwable cause) {
        // 堆栈信息跟踪
        fillInStackTrace();
        detailMessage = (cause==null ? null : cause.toString());
        this.cause = cause;
    }
    
    // 构造函数
    protected Throwable(String message, Throwable cause,
                        boolean enableSuppression,
                        boolean writableStackTrace) {
        // 传入参数，是否进行堆栈跟踪
        if (writableStackTrace) {
            fillInStackTrace();
        } else {
            stackTrace = null;
        }
        detailMessage = message;
        this.cause = cause;
        // 是否启用抑制
        if (!enableSuppression)
            suppressedExceptions = null;
    }
    
    // 返回此throwable的详细消息字符串。
    public String getMessage() {
        return detailMessage;
    }
    
    // 创建此可抛出的本地化描述。 子类可以覆盖此方法，以生成特定于区域的消息。
    public String getLocalizedMessage() {
        return getMessage();
    }
    
    // 抛出可能的原因
    public synchronized Throwable getCause() {
        return (cause==this ? null : cause);
    }
    
    // 将此throwable的原因初始化为指定值
    public synchronized Throwable initCause(Throwable cause) {
        if (this.cause != this)
            throw new IllegalStateException("Can't overwrite cause with " +
                                            Objects.toString(cause, "a null"), this);
        if (cause == this)
            throw new IllegalArgumentException("Self-causation not permitted", this);
        this.cause = cause;
        return this;
    }
    
    // 返回此可抛出的简短描述。
    public String toString() {
        String s = getClass().getName();
        String message = getLocalizedMessage();
        // 类名与可抛的信息
        return (message != null) ? (s + ": " + message) : s;
    }
    
    // 
    public void printStackTrace() {
        printStackTrace(System.err);
    }
    
    // 此方法在错误输出流上为该Throwable对象打印一个堆栈跟踪，该值为字段System.err的值
    public void printStackTrace(PrintStream s) {
        printStackTrace(new WrappedPrintStream(s));
    }
    
    // 打印出错误的信息
    private void printStackTrace(PrintStreamOrWriter s) {
        // 定义一个set集合用于存储错误的信息
        Set<Throwable> dejaVu =
            Collections.newSetFromMap(new IdentityHashMap<Throwable, Boolean>());
        // 将当前的错误信息添加进去
        dejaVu.add(this);
        
        // s.lock() 返回printStream打印流对象
        // 即只有对象获到printStream时才能进入下面的同步代码块中
        synchronized (s.lock()) {
            s.println(this);
            // 获取到异常的信息
            StackTraceElement[] trace = getOurStackTrace();
            // 遍历 将异常的信息打印出来。
            for (StackTraceElement traceElement : trace)
                s.println("\tat " + traceElement);
            // 封闭堆栈跟踪
            for (Throwable se : getSuppressed())
                se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION, "\t", dejaVu);
            Throwable ourCause = getCause();
            // 
            if (ourCause != null)
                ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, "", dejaVu);
        }
    }
    

    private void printEnclosedStackTrace(PrintStreamOrWriter s,
                                         StackTraceElement[] enclosingTrace,
                                         String caption,
                                         String prefix,
                                         Set<Throwable> dejaVu) {
        // assert 断言，不懂这里为什么要加上断言
        assert Thread.holdsLock(s.lock());
        // 异常信息中是否包含当前类的异常
        if (dejaVu.contains(this)) {
            s.println("\t[CIRCULAR REFERENCE:" + this + "]");
        } else {
            // 将当前的信息添加进入到dejaVe中
            dejaVu.add(this);
            // 获取到所有的异常信息
            StackTraceElement[] trace = getOurStackTrace();
            // 异常数组最大的下标
            int m = trace.length - 1;
            int n = enclosingTrace.length - 1;
            while (m >= 0 && n >=0 && trace[m].equals(enclosingTrace[n])) {
                // 找到trace与enclosingTrace不同的下标位置，
                m--; n--;
            }
            // 计算相同之后的剩下元素的个数
            int framesInCommon = trace.length - 1 - m;
            s.println(prefix + caption + this);
            // 将相同的异常信息打印出来。
            for (int i = 0; i <= m; i++)
                s.println(prefix + "\tat " + trace[i]);
            // 剩下元素的个数不为0， 用... 代替
            if (framesInCommon != 0)
                s.println(prefix + "\t... " + framesInCommon + " more");
            // 
            for (Throwable se : getSuppressed())
                // 递归调用，向下查找进一步的异常原因
                // 也就是我们程序报错时，控制台出现的：原因 ——> 异常信息 ——>原因  ——> 异常信息
                se.printEnclosedStackTrace(s, trace, SUPPRESSED_CAPTION,
                                           prefix +"\t", dejaVu);
            // 获取到异常可能的原因
            Throwable ourCause = getCause();
            if (ourCause != null)
                ourCause.printEnclosedStackTrace(s, trace, CAUSE_CAPTION, prefix, dejaVu);
        }
    }
    
    // 打印异常信息
    public void printStackTrace(PrintWriter s) {
        printStackTrace(new WrappedPrintWriter(s));
    }
    
    // 内部抽象类
    private abstract static class PrintStreamOrWriter {
        abstract Object lock();
        abstract void println(Object o);
    }
    
    // 内部类
    private static class WrappedPrintStream extends PrintStreamOrWriter {
        // 定义一个输出流，拼接传入的流对象
        private final PrintStream printStream;
        
        // 将传入的流赋值给当前的printString
        WrappedPrintStream(PrintStream printStream) {
            this.printStream = printStream;
        }
        
        // 返回printStream
        Object lock() {
            return printStream;
        }
        
        // 将信息打印出来
        void println(Object o) {
            printStream.println(o);
        }
    }
    
    // 内部类，(还没有看IO流，不太懂下面代码的意思)
    private static class WrappedPrintWriter extends PrintStreamOrWriter {
        private final PrintWriter printWriter;
        WrappedPrintWriter(PrintWriter printWriter) {
            this.printWriter = printWriter;
        }
        Object lock() {
            return printWriter;
        }
        void println(Object o) {
            printWriter.println(o);
        }
    }
    
    // 填写执行堆栈跟踪。 该方法记录了此Throwable对象信息，了解当前线程的堆栈帧的当前状态。 
    public synchronized Throwable fillInStackTrace() {
        if (stackTrace != null || backtrace != null ) {
            fillInStackTrace(0);
            stackTrace = UNASSIGNED_STACK;
        }
        return this;
    }
    
    // 本地方法，堆栈信息
    private native Throwable fillInStackTrace(int dummy);
    
    // 
    public StackTraceElement[] getStackTrace() {
        return getOurStackTrace().clone();
    }
    
    // 获取到所有的异常信息
    // 异常的信息存储在stackTrace中
    private synchronized StackTraceElement[] getOurStackTrace() {
        //  添加异常信息的条件（不懂这里代码的意思）
        if (stackTrace == UNASSIGNED_STACK ||
            (stackTrace == null && backtrace != null)) {
            // 获取当前栈的深度
            int depth = getStackTraceDepth();
            // 定义一个stackTraceElement数组，大小为当前对象能到达的深度，
            stackTrace = new StackTraceElement[depth];
            for (int i=0; i < depth; i++)
                // 遍历将异常的信息存在stackce[]中
                stackTrace[i] = getStackTraceElement(i);
        } else if (stackTrace == null) {
            return UNASSIGNED_STACK;
        }
        return stackTrace;
    }
    
    // 设置将被返回的堆栈微量元素getStackTrace()和由印刷printStackTrace()和相关方法
    public void setStackTrace(StackTraceElement[] stackTrace) {
        StackTraceElement[] defensiveCopy = stackTrace.clone();
        // 遍历堆栈信息是否需要抛异常
        for (int i = 0; i < defensiveCopy.length; i++) {
            // 如果stackTrace是 null，或者如果任何的元件的 stackTrace是 null,就报NullPointerException
            if (defensiveCopy[i] == null)
                throw new NullPointerException("stackTrace[" + i + "]");
        }

        synchronized (this) {
            if (this.stackTrace == null && // 不变的堆栈
                backtrace == null) // Test for out of protocol state
                return;
            // 将
            this.stackTrace = defensiveCopy;
        }
    }
    
    // 获取到栈的深度
    native int getStackTraceDepth();
    
    // 返回堆栈跟踪的指定元素。
    native StackTraceElement getStackTraceElement(int index);

    // 私有方法，在这个类的其它地方没有使用到，不知道什么意思
    private void readObject(ObjectInputStream s)
        throws IOException, ClassNotFoundException {
        s.defaultReadObject();     // read in all fields
        if (suppressedExceptions != null) {
            List<Throwable> suppressed = null;
            if (suppressedExceptions.isEmpty()) {
                suppressed = SUPPRESSED_SENTINEL;
            } else { // Copy Throwables to new list
                suppressed = new ArrayList<>(1);
                for (Throwable t : suppressedExceptions) {
                    if (t == null)
                        throw new NullPointerException(NULL_CAUSE_MESSAGE);
                    if (t == this)
                        throw new IllegalArgumentException(SELF_SUPPRESSION_MESSAGE);
                    suppressed.add(t);
                }
            }
            suppressedExceptions = suppressed;
        }
        if (stackTrace != null) {
            if (stackTrace.length == 0) {
                stackTrace = UNASSIGNED_STACK.clone();
            }  else if (stackTrace.length == 1 &&
                        SentinelHolder.STACK_TRACE_ELEMENT_SENTINEL.equals(stackTrace[0])) {
                stackTrace = null;
            } else {
                for(StackTraceElement ste : stackTrace) {
                    if (ste == null)
                        throw new NullPointerException("null StackTraceElement in serial stream. ");
                }
            }
        } else {
            stackTrace = UNASSIGNED_STACK.clone();
        }
    }
    
    // 私有方法，在这个类的其它地方没有使用到，不知道什么意思
    private synchronized void writeObject(ObjectOutputStream s)
        throws IOException {
        getOurStackTrace();
        StackTraceElement[] oldStackTrace = stackTrace;
        try {
            if (stackTrace == null)
                stackTrace = SentinelHolder.STACK_TRACE_SENTINEL;
            s.defaultWriteObject();
        } finally {
            stackTrace = oldStackTrace;
        }
    }
    
    // 将指定的异常附加到为了传递此异常而被抑制的异常
    public final synchronized void addSuppressed(Throwable exception) {
        // 指定的异常与当前的异常不相同
        if (exception == this)
            throw new IllegalArgumentException(SELF_SUPPRESSION_MESSAGE, exception);
        // 指定的异常为空，
        if (exception == null)
            throw new NullPointerException(NULL_CAUSE_MESSAGE);
        // 没有异常？
        if (suppressedExceptions == null) // Suppressed exceptions not recorded
            return;
        // 
        if (suppressedExceptions == SUPPRESSED_SENTINEL)
            suppressedExceptions = new ArrayList<>(1);
        // 将当前的异常添加进入supperssedEx
        suppressedExceptions.add(exception);
    }
    
    // 定义一个空的可抛变量，抑制的异常为空时，就将这个返回
    private static final Throwable[] EMPTY_THROWABLE_ARRAY = new Throwable[0];

    // 一个数组，其中包含所有被抑制以提供此异常的异常。
    public final synchronized Throwable[] getSuppressed() {
        // 如果抑制的异常为空，那么就返回空的异常数组
        if (suppressedExceptions == SUPPRESSED_SENTINEL ||
            suppressedExceptions == null)
            return EMPTY_THROWABLE_ARRAY;
        else
            // 如果抑制异常数据不为空，那么就将数组转成集合返回回去。
            return suppressedExceptions.toArray(EMPTY_THROWABLE_ARRAY);
    }
}

 

WoodieWang
关注
专栏目录
【保姆级】手把手捋动态代理流程（JDK+Cglib超详细源码分析）
aqin1012的博客
02-23 23万+
动态代理，通俗点说就是：无需声明式的创建java代理类，而是在运行过程中生成"虚拟"的代理类，被ClassLoader加载。从而避免了静态代理那样需要声明大量的代理类。上面的简介中提到了两个关键的名词：“静态代理”和“动态代理”我们先来看来下两个问题：首先什么是代理呢？它可以看作是对最终调用目标的一个封装，可以通过操作代理对象来调用目标类，这样就可以实现调用者和目标对象的解耦合“静态代理”和“动态代理”又有什么区别呢？
Java异常处理 Throwable实现方法解析
08-25
主要介绍了Java异常处理 Throwable实现方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Java Throwable源码解读
aicyo8644的博客
08-21 126
package java.lang; import java.io.*; /** * * Throwable是所有Error和Exceptiong的父类 * 注意它有四个构造函数: * Throwable() * Throwable(String message) ...
源码解析之Throwable
FDargon的博客
03-22 2045
Throwable 类是exceptions和error的父类。只有作为此类（或其某个子类）实例的对象才会由Java虚拟机抛出，或者可以由Java throw语句抛出。 同样，只有这个类或它的一个子类可以是catch子句中的参数类型。 由于java检查编译时异常的存在，Throwable和Throwable的任何子类（不是RuntimeException或Error的子类）均被视为检查异常。通常用...
Throwable源码详解
a768818702的博客
03-10 410
packagejava.lang; importjava.io.*; /** * *Throwable是所有Error和Exceptiong的父类 *注意它有四个构造函数: *Throwable() *Throwable(String message) *Throw...
java源码分析（7）-Throwable
别叫我风哥的博客
06-01 1444
 Throwable 1.Throwable类 Throwable类实现了Serializable 接口，此类可用于序列化 public class Throwable implements Serializable {     private transient Object backtrace;     private String detailMessage;//用于存放异常
Throwable源码异常分析
Tiger的专栏
09-09 704
问题： Throwable是所有异常的父类，那么异常到底包含哪些信息呢？ 1.Throwable包含哪些成员变量？ public class Throwable implements Serializable { private transient volatile Object backtrace; //异常信息 private String detailMessage; //当前异常是由哪个Throwable所引起的 private Throwable c
Gradle 源码分析
薛瑄的博客
07-05 1241
这是一篇Gradle 进阶文章，我假设你已经会 gradle task，自定义plugin 开发。我会带你从源码分析Gradle的整体过程，不会涉及具体的细节，如果分析过细，够写一本书了。建议你参照文章 反复阅读源码，一定会有写这本书的能力。文章是基于Gradle 6.7版本 文章目录一、 启动Gradle下载指定版本的Gradle启动Gradle流程二、 Gradle 的五大流程2.1 LoadSettings2.1.1 、生命周期接口回调2.1.2 、执行init.gradle2.1.3 、查找sett
08-Hystrix源码分析1
08-03
Hystrix源码分析1 Hystrix是一个流行的熔断器工具，用于防止服务雪崩效应。它通过对方法的AOP拦截来实现熔断和降级。下面是Hystrix源码分析的主要知识点： 1. HystrixCommandAspect类 HystrixCommandAspect是...
Android Gradle源码分析
一个码农的博客
06-04 2669
一.如何调试Android Gralde源码 最简单的方式如下： 1.配置 gradle.properties 比较方便的做法是配置全局的 gradle.properties，这样对所有 Gradle 工具都适用，配置文件位于 ~/.gradle/gradle.properties，在 gradle.properties 文件中加上 org.gradle.jvmargs 属性： org.gradle.jvmargs=-XX:MaxPermSize=4g -XX:+HeapDumpOnOutOfMemoryE
解析Java中所有错误和异常的父类java.lang.Throwable
09-02
主要介绍了Java中所有错误和异常的父类java.lang.Throwable,文章中简单地分析了其源码,说明在代码注释中,需要的朋友可以参考下
Java异常学习一：Throwable源码
zy19982004的专栏
11-14 258
一.java异常类结构 常用的CheckedException 常用的RuntimeException   二.Throwable类源码  StackTraceElement。一个final类，代表栈轨迹中的元素，一个异常可能有多个元素。 public final class StackTraceElement implements java.io.Serializabl...
Throwable源码
zhaoqian19921029的博客
07-31 294
package java.lang; import java.io.*; import java.util.*; public class Throwable implements Serializable { 序列号版本号 private static final long serialVersionUID = -3042686055658047285L; 定...
java throwable_JAVA异常类Throwable解析
weixin_34329350的博客
02-12 4327
在 Java 中，所有的异常都有一个共同的祖先java.lang包中的 Throwable类。Throwable： 有两个重要的子类：Exception(异常)和 Error(错误) ；二者都是Java 异常处理的重要子类，各自都包含大量子类。Error(错误):是程序无法处理的错误，表示运行应用程序中较严重问题。大多数错误与代码编写者执行的操作无关，而表示代码运行时 JVM(Java 虚拟机)...
Throwable 类源码详情
caijibaindashen的博客
08-28 173
Throwable 类源码详情Throwable 类源码详情主要属性构造方法常用的方法 Throwable 类源码详情 主要属性 /** * Native code saves some indication of the stack backtrace in this slot. *///栈的回溯信息 private transient Object backtrace; //详细信息 private String detailMessage;
Java中Throwable源码阅读
午-夜
07-09 1275
Throwable 源码阅读笔记 读的不是很懂，但是大致明白自定义异常中的那几个常用的参数的发源地了，这是项目中自定义异常经常使用的几个参数和方法，在Throwable中都可以查到影子： protected String positionName; protected String labelName; protected String message="";  publi
【JavaSE】Throwable接口详解
兴趣是最好的老师
05-30 2057
Throwable的两个子类：Error和Exception。Error发生在JVM层次的错误，无法捕捉，该错误是不可恢复的。Exception可恢复的异常，包括运行时异常RuntimeException、检查异常CheckedException。
JavaSE基础(86) Throwable体系
郑清
08-27 588
Throwable体系：1.Error：错误 2.Exception：异常 ①RuntimeException:运行时异常 在编译期不会 报错。不会强制要求处理。 == 》 原因：运行时异常出现频率较高。 ②其他Exception：非运行时异常 在编译期必须处理。 但是处理的原理 与 运行时异常 完全一致 ex1： Error：错误 ex2: Run...
模糊知识点Throwable体系
zhouren1314的专栏
05-25 778
由于这块认识不是很全面，特地把这里认真的看了一遍，
ObservableZipIterable 源码分析
最新发布
06-09
下面是该类的源码分析： ``` final class ObservableZipIterable, U, V> extends Observable<V> { final Iterable<? extends ObservableSource<? extends T>> sources; final Function[], ? extends V> zipper; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值