黑马程序员技术交流社区

标题: Thread源代码简介 [打印本页]

作者: taozhihui 时间: 2016-9-22 23:30
标题: Thread源代码简介
package java.lang;
import java.io.*;
/**
*
* Throwable是所有Error和Exceptiong的父类
* 注意它有四个构造函数:
* Throwable()
* Throwable(String message)
* Throwable(Throwable cause)
* Throwable(String message, Throwable cause)
*
*/
public class Throwable implements Serializable {
      private static final long serialVersionUID = -3042686055658047285L;

      /**
         * Native code saves some indication of the stack backtrace in this slot.
         */
      private transient Object backtrace;

      /**
         * 描述此异常的信息
         */
      private String detailMessage;

      /**
         * 表示当前异常由那个Throwable引起
         * 如果为null表示此异常不是由其他Throwable引起的
         * 如果此对象与自己相同,表明此异常的起因对象还没有被初始化
         */
      private Throwable cause = this;

      /**
         * 描述异常轨迹的数组
         */
      private StackTraceElement[] stackTrace;

      /**
         * 构造函数,起因对象没有被初始化可以在以后使用initCause进行初始化
         * fillInStackTrace可以用来初始化它的异常轨迹的数组
         */
      public Throwable() {
            fillInStackTrace();
      }

      /**
         * 构造函数
         */
      public Throwable(String message) {
         //填充异常轨迹数组
            fillInStackTrace();
         //初始化异常描述信息
            detailMessage = message;
      }

      /**
         * 构造函数,cause表示起因对象
         */
      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;
      }

      /**
         * 获取详细信息
         */
      public String getMessage() {
            return detailMessage;
      }

      /**
         * 获取详细信息
         */
      public String getLocalizedMessage() {
            return getMessage();
      }

      /**
         * 获取起因对象
         */
      public Throwable getCause() {
            return (cause==this ? null : cause);
      }

      /**
         * 初始化起因对象,这个方法只能在未被初始化的情况下调用一次
         */
      public synchronized Throwable initCause(Throwable cause) {
         //如果不是未初始化状态则抛出异常
            if (this.cause != this)
               throw new IllegalStateException("Can't overwrite cause");

         //要设置的起因对象与自身相等则抛出异常
            if (cause == this)
               throw new IllegalArgumentException("Self-causation not permitted");

         //设置起因对象
            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);
      }

      /**
         * 打印出错误轨迹
         */
      public void printStackTrace(PrintStream s) {
            synchronized (s) {
            //调用当前对象的toString方法
               s.println(this);
            //获取异常轨迹数组
               StackTraceElement[] trace = getOurStackTrace();

            //打印出每个元素的字符串表示
               for (int i=0; i < trace.length; i++)
                  s.println("\tat " + trace[i]);

            //获取起因对象
               Throwable ourCause = getCause();

            //递归的打印出起因对象的信息
               if (ourCause != null)
                  ourCause.printStackTraceAsCause(s, trace);
            }
      }

      /**
         * 打印起因对象的信息
         * @param s 打印的流
         * @param causedTrace 有此对象引起的异常的异常轨迹
         */
      private void printStackTraceAsCause(PrintStream s,
                                          StackTraceElement[] causedTrace)
      {
         //获得当前的异常轨迹
            StackTraceElement[] trace = getOurStackTrace();
         //m为当前异常轨迹数组的最后一个元素位置,
         //n为当前对象引起的异常的异常轨迹数组的最后一个元素
            int m = trace.length-1, n = causedTrace.length-1;
         //分别从两个数组的后面做循环,如果相等则一直循环,直到不等或数组到头
            while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {
               m--; n--;
         }

         //相同的个数
            int framesInCommon = trace.length - 1 - m;

         //打印出不同的错误轨迹
            s.println("Caused by: " + this);
            for (int i=0; i <= m; i++)
               s.println("\tat " + trace[i]);
            //如果有相同的则打印出相同的个数
            if (framesInCommon != 0)
               s.println("\t... " + framesInCommon + " more");

         //获得此对象的起因对象,并递归打印出信息
            Throwable ourCause = getCause();
            if (ourCause != null)
               ourCause.printStackTraceAsCause(s, trace);
      }

      /**
         * 打印出错误轨迹
         */
      public void printStackTrace(PrintWriter s) {
            synchronized (s) {
               s.println(this);
               StackTraceElement[] trace = getOurStackTrace();
               for (int i=0; i < trace.length; i++)
                  s.println("\tat " + trace[i]);

               Throwable ourCause = getCause();
               if (ourCause != null)
                  ourCause.printStackTraceAsCause(s, trace);
            }
      }

      /**
         * 打印起因对象的信息
         */
      private void printStackTraceAsCause(PrintWriter s,
                                          StackTraceElement[] causedTrace)
      {
            // assert Thread.holdsLock(s);

            // Compute number of frames in common between this and caused
            StackTraceElement[] trace = getOurStackTrace();
            int m = trace.length-1, n = causedTrace.length-1;
            while (m >= 0 && n >=0 && trace[m].equals(causedTrace[n])) {
               m--; n--;
            }
            int framesInCommon = trace.length - 1 - m;

            s.println("Caused by: " + this);
            for (int i=0; i <= m; i++)
               s.println("\tat " + trace[i]);
            if (framesInCommon != 0)
               s.println("\t... " + framesInCommon + " more");

            // Recurse if we have a cause
            Throwable ourCause = getCause();
      if (ourCause != null)
               ourCause.printStackTraceAsCause(s, trace);
      }

      /**
         * 填充异常轨迹
         */
      public synchronized native Throwable fillInStackTrace();

      /**
         * 返回当前的异常轨迹的拷贝
         */
      public StackTraceElement[] getStackTrace() {
            return (StackTraceElement[]) getOurStackTrace().clone();
      }


      /**
         * 获取当前的异常轨迹
         */
   private synchronized StackTraceElement[] getOurStackTrace() {
         //如果第一次调用此方法则初始化异常轨迹数组
            if (stackTrace == null) {
            //获得异常轨迹深度
               int depth = getStackTraceDepth();
            //创建新的异常轨迹数组,并填充它
               stackTrace = new StackTraceElement[depth];

            for (int i=0; i < depth; i++)
                  stackTrace[i] = getStackTraceElement(i);//获取指定位标的异常轨迹
            }

            return stackTrace;
      }

      /**
         * 设置异常轨迹
         */
      public void setStackTrace(StackTraceElement[] stackTrace) {
         //拷贝设置参数
            StackTraceElement[] defensiveCopy =
               (StackTraceElement[]) stackTrace.clone();

         //如果设置参数有空元素则抛出异常
            for (int i = 0; i < defensiveCopy.length; i++)
               if (defensiveCopy[i] == null)
                  throw new NullPointerException("stackTrace[" + i + "]");

         //设置当前对象的异常轨迹
            this.stackTrace = defensiveCopy;
      }

      /**
         * 异常轨迹的深度,0表示无法获得
         */
      private native int getStackTraceDepth();

      /**
         * 获取指定位标的异常轨迹
         */
      private native StackTraceElement getStackTraceElement(int index);


      private synchronized void writeObject(java.io.ObjectOutputStream s)
            throws IOException
      {
            getOurStackTrace();
            s.defaultWriteObject();
      }
}

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2