private String detailMessage;

private Throwable cause = this;

/*
* 表示空堆栈，在所有空堆栈的异常中共享此字段
*/
private static final StackTraceElement[] UNASSIGNED_STACK = new StackTraceElement[0];
private StackTraceElement[] stackTrace = UNASSIGNED_STACK;

/*
* 调用本地方法来填充堆栈
*/
private native Throwable fillInStackTrace(int dummy);

private final char value[];
private int hash; // Default to 0
public int length() {
   return value.length;
}

/** JDK9+ **/
private final byte value[]; 
public int length() {
   return value.length >> coder();   //当使用UTF16编码方式时，2字节一个代码单元，因此长度需要除2
}
byte coder() {
   return COMPACT_STRINGS ? coder : UTF16;
}
@Native static final byte LATIN1 = 0;
@Native static final byte UTF16  = 1;
/** JDK9+ end **/

//hotspot/agent/src/share/classes/sun/jvm/hotspot/runtime/VM.java
public int getObjectAlignmentInBytes() {
   if (objectAlignmentInBytes == 0) {
      Flag flag = getCommandLineFlag("ObjectAlignmentInBytes");
      objectAlignmentInBytes = (flag == null) ? 8 : (int)flag.getIntx();
   }
   return objectAlignmentInBytes;
}

char[] value;
int count;

/** JDK9+ **/
byte[] value;
byte coder;
/** JDK9+ end **/

    static final CharacterData of(int ch) {
        if (ch >>> 8 == 0) {     // fast-path
            return CharacterDataLatin1.instance;
        } else {
            switch(ch >>> 16) {  //plane 00-16
            case(0):
                return CharacterData00.instance;
            case(1):
                return CharacterData01.instance;
            case(2):
                return CharacterData02.instance;
            case(14):
                return CharacterData0E.instance;
            case(15):   // Private Use
            case(16):   // Private Use
                return CharacterDataPrivateUse.instance;
            default:
                return CharacterDataUndefined.instance;
            }
        }
    }

//一个字符串列表，包含调用子进程应用及其参数
List<String> command;

//一组环境变量的Map，默认继承当前进程，可以通过`System.getenv()`获取。
File directory;

//工作目录，默认工作目录是当前进程的工作目录
Map<String,String> environment;

/**
长度为3，使用数组位区分是输入流、输出流和异常流，全部默认为管道流：
1. `redirects[0]`表示输入流，可以通过`Process.getOutputStream()`获取此流，但是如果通过redirectInput重定向到其他源后`Process.getOutputStream()`会返回一个空的输出流：
   + write方法抛出IOException
   + close方法无效
2. `redirects[1]`表示输出源，可以通过`Process.getInputStream()`获取此流，但是如果通过redirectOutput重定向到其他源后`Process.getInputStream()`会返回一个空的输入流：
   + read方法总是返回-1
   + available方法总是返回0
   + close方法无效
3. `redirects[2]`表示异常源，可以通过`Process.getErrorStream()`获取此流，但是如果通过redirectError重定向到其他源后`Process.getErrorStream()`会返回一个空的输入流：
   + read方法总是返回-1
   + available方法总是返回0
   + close方法无效
**/
Redirect[] redirects;

/**
默认为false，表示子进程的标准输出和标准异常是两个单独的流。如果设置为true后：
   + 标准输出和标准异常将使用同一个流
   + 标准输出和标准异常可以使用redirectOutput重定向
   + 创建子进程时，将忽略由redirectError方法设置的任何重定向
   + 从`Process.getErrorStream()`返回的流将始终是空输入流
**/
boolean redirectErrorStream;

//如果Thread类没有被继承，Thread.run没有被重写，那么会Thread.run会调用target.run来执行用户代码。
private Runnable target;

//创建线程时请求的栈大小，可以被虚拟机重写和忽略。
private long stackSize;

//返回执行当前代码的线程
public static native Thread currentThread();

/**
通知调度程序当前线程原意放弃CPU占用。调度程序可以随意忽略此通知。Yield是一种启发式编程的尝试，很少适合使用这种方法。
它对于调试或测试目的可能很有用，它可能有助于重现由于竞争条件引起的错误。
在设计并发控制结构（例如`java.util.concurrent.locks`包中的结构）时，它也很有用
**/
public static native void yield();

//使当前正在执行的线程休眠（暂时停止执行）指定的毫秒数，取决于系统计时器和调度程序的精度和准确性。该线程不会失去对任何监视器的占有。
public static native void sleep(long millis) throws InterruptedException;

//所有的Thread构造方法都会调用init方法进行初始化。
private void init(ThreadGroup g, Runnable target, String name, long stackSize, AccessControlContext acc, boolean inheritThreadLocals);

//启动这个线程，start方法不可以被多次调用。最终会调用native方法`start0()`;
public synchronized void start();

//调用用户代码。如果继承了Thread类，应该重写此方法。否则应该传入Runnable对象。
public void run();

//由虚拟机调用做线程结束前的清理操作
private void exit();

/**
此方法不安全，已经被弃用。强制停止一个线程。如果停止了一个未启动的线程，线程启动后会立刻停止。
如果一个线程被强制停止，会解锁它锁定的所有监视器，如果这些监视器保护的对象处于一个不一致的状态，
释放后不一致状态会对其他线程可见，会引发未知错误。正确的停止线程方式应该是让线程自己退出run方法。
这个方法最终会调用native的`stop0()`方法。
**/
public final void stop();

/**
中断线程，如果线程被wait、join、sleep方法阻塞，则调用interrupt会抛出InterruptedException。
此方法只是设置中断标识，并不会立刻中断线程。运行中的线程会在某些节点检查中断状态来进行中断。
也就是说调用了interrupt后，线程会在未知的位置中断。对一个非活跃线程调用interrupt不会有任何影响，因为线程不活跃就无法检查中断标识。
此方法最终会调用native的`interrupt0()`。
**/
public void interrupt();

/**
这是一个静态方法，测试当前线程是否中断。此方法调用后会清除线程的中断标识。也就是说第一次调用返回true，第二次调用将返回false。
此方法最终会调用native的`isInterrupted`，并传入true（清除状态）。
**/
public static boolean interrupted();

//测试线程是否被中断，不会清除状态位。此方法最终会调用native的`isInterrupted`，并传入false（不清除状态）。
public boolean isInterrupted();

//此方法没有被实现且已经被弃用。旨在提供一个不释放任何资源和锁的情况下销毁一个线程的方法。
public void destroy();

//测试线程是否存活
public final native boolean isAlive();

//已经被弃用，因为会导致死锁。暂停一个线程，如果线程是活动的，它将被挂起，直到调用`resume()`。
public final void suspend();

//已经被弃用，此方法仅用于恢复被挂起的线程，suspend会导致死锁。
public final void resume();

//改变线程的优先级，但是不能超过线程组中允许的最大优先级，超过取最小。
public final void setPriority;

/**
在A线程中调用B线程的join方法，A线程中调用之后的代码等待B线程结束后执行。
其实现方法是使用了`this.isAlive`为条件的`this.wait`循环，当线程B终止时会调用`this.notifyAll`。
建议用户不要手动调用线程实例的wait、notify或notifyAll方法，这些方法用于在锁对象上调用。
**/
public final synchronized void join(long millis);

//判断线程是否持有目标锁对象。
public static native boolean holdsLock(Object obj);

//线程状态枚举
public enum State {
   //线程创建了还没有调用start()
   NEW,

   //在Java中线程的Redy和Running统称为Runnable。指线程调用了start。此状态下线程可能已经在运行，也可能在等待系统调度。
   RUNNABLE,

   //线程等待synchronized锁后进入此状态
   BLOCKED,

   //线程由于调用wait、join、park方法进入等待状态
   WAITING,

   //线程由于调用带有超时时间的wait、join、park方法进入超时等待状态
   TIMED_WAITING,

   //线程已经执行完成进入终止状态
   TERMINATED;
}

public class ThreadGroup implements Thread.UncaughtExceptionHandler{
   private final ThreadGroup parent;
   String name;
   int maxPriority;
   boolean destroyed;
   boolean daemon;
   boolean vmAllowSuspension;

   int nUnstartedThreads = 0;
   int nthreads;
   Thread threads[];

   int ngroups;
   ThreadGroup groups[];
}

public class Thread implements Runnable {
   ...
   ThreadLocal.ThreadLocalMap threadLocals = null;
}

public class ThreadLocal<T> {

   private static AtomicInteger nextHashCode = new AtomicInteger();

   public T get() {
      getMap(Thread.currentThread()).getEntry(this);
   }

   public void set(T value) {
      getMap(Thread.currentThread()).set(this, value);
   }

   public void remove() {
      getMap(Thread.currentThread()).remove(this);
   }

   ThreadLocalMap getMap(Thread t) {
        return t.threadLocals;
    }

    static class ThreadLocalMap {
         
      static class Entry extends WeakReference<ThreadLocal<?>> {
         Object value;

         Entry(ThreadLocal<?> k, Object v) {
            super(k);
            value = v;
         }
      }
       ...
      private Entry[] table;

      private Entry getEntry(ThreadLocal<?> key) {
         ...
         expungeStaleEntry()
      }

      private void set(ThreadLocal<?> key, Object value) {
         ...
         index=key.threadLocalHashCode & (table.len-1)
         expungeStaleEntry()
      }

      private void remove(ThreadLocal<?> key) {
         ...
         expungeStaleEntry()
      }

      private int expungeStaleEntry(int staleSlot) {
         //清理table中key==null的项
      }

    }

}

public class Thread implements Runnable {
   ...
   ThreadLocal.ThreadLocalMap inheritableThreadLocals = null;

   private void init(ThreadGroup g, Runnable target, String name,long stackSize, AccessControlContext acc,boolean inheritThreadLocals) {
      ...
      if (inheritThreadLocals && parent.inheritableThreadLocals != null){
         this.inheritableThreadLocals = ThreadLocal.createInheritedMap(parent.inheritableThreadLocals);
      }
   }
}

public class InheritableThreadLocal<T> extends ThreadLocal<T> {
   ThreadLocalMap getMap(Thread t) {
      return t.inheritableThreadLocals;
   }
}

/**
父加载器，维持委派模型
Note: VM hardcoded the offset of this field, thus all new fields must be added *after* it.
**/
private final ClassLoader parent;

/**
并行类加载时synchronized块对加载的不同类分开持有锁对象。
JVM使用这个字段来判断类加载器是否具有并行能力，以及选择类加载的合适锁对象
**/
private final ConcurrentHashMap<String, Object> parallelLockMap;

//自定义类加载器应该重写findClass方法而不是重写此方法。
protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException{
   synchronized (getClassLoadingLock(name)) {  //使用parallelLockMap
      Class c = findLoadedClass(name);
      if(c==null){
         if(parent!=null){
            c=parent.loadCalss(name,false);
         }else{
            c=findBootstrapClassOrNull(name);  //没父加载器就要调用bootstrap class loader
         }
         。。。
         if(c==null){
            c=findClass(name);      //最后才自己尝试装载类
         }
      }
      if(resolve){
         resolveClass(c);    //如果需要，装载后马上进行解析
      }
   }
}

//默认实现抛出ClassNotFoundException，用于重写实现自定义加载器查找类
protected Class<?> findClass(String name) throws ClassNotFoundException {
   throw new ClassNotFoundException(name);
}

//使用原始字节数组创建Class对象。其实调用native方法，由c++实现。
protected final Class<?> defineClass(String name, byte[] b, int off, int len) throws ClassFormatError{...} //+2重载
private native Class<?> defineClass0(String name, byte[] b, int off, int len, ProtectionDomain pd); //+2重载

//校验自定义加载的类不能是`java.*`为开头的包。
private ProtectionDomain preDefineClass(String name, ProtectionDomain pd){...}

//类能被使用需要经过加载和链接，此方法链接加载的类，最终调用native方法，由c++实现
protected final void resolveClass(Class<?> c){...}
private native void resolveClass0(Class<?> c);

//查找已经被引导类加载器加载的类，最终调用native方法，由c++实现
private Class<?> findBootstrapClassOrNull(String name){...}

//查找已经被加载过的类，最终调用native方法，由c++实现
protected final Class<?> findLoadedClass(String name){...}
private native final Class<?> findLoadedClass0(String name);

/**
加载类或接口，initialize表示是否加载后进行初始化。loader指定加载器进行加载;
此方法不能用于原始类型或void的。如果是数组类，则数组类的组件类型被加载但不被初始化。
**/
public static Class<?> forName(String className) throws ClassNotFoundException{...}
public static Class<?> forName(String name, boolean initialize, ClassLoader loader) throws ClassNotFoundException{...}
private static native Class<?> forName0(String name, boolean initialize, ClassLoader loader, Class<?> caller)

/**
使用无参构造器创建一个此Class对象的新实例。如果尚未初始化该类，则将其初始化。
**/
public T newInstance() throws InstantiationException, IllegalAccessException {...}

/**
返回此Class的全名。如果Class表示原始类型或void，则返回对应Java语言关键字（如int、void）。
如果是数组，则前面加"["符号，符号数量表示数组深度。
**/
public String getName(){...}
private native String getName0();
/**
返回类名。如果是匿名类，则返回一个空字符串。
数组的简单名称是附加了“[]”的组件类型的简单名称。特别是组件类型为匿名的数组的简单名称是“[]”
<https://stackoverflow.com/questions/15202997/what-is-the-difference-between-canonical-name-simple-name-and-class-name-in-jav/15203417#15203417>
**/
public String getSimpleName(){...}
public String getCanonicalName(){...}
public String getTypeName(){...}

/**
获得父类，此方法可以用于获取带泛型的父类。Type中包含泛型信息。
如果表示Object类、接口、原始类型或 void，则返回 null。如
果此对象表示数组类，则返回Object类。
**/
public Type getGenericSuperclass(){...}

/**
返回所有实现的接口，包括接口中继承的接口，按照implements和extends顺序返回。
如果此对象表示数组类型，则接口Cloneable和java.io.Serializable将按该顺序返回
**/
public Class<?>[] getInterfaces(){...}
private native Class<?>[] getInterfaces0();

/**
返回值int的每一位表示一个修饰符。修饰符由public、protected、private、final、static、abstract和interface常量组成，见[java.lang.reflect.Modifier]
如果底层类是一个数组类，那么它的public、private 和 protected 修饰符与其组件类型的修饰符相同。
如果此类表示原始类型或void，则其public修饰符始终为true，其protected和private修饰符始终为false。
如果此对象表示数组类、原始类型或void，则其final修饰符始终为true，其接口修饰符始终为false。
**/
public native int getModifiers();

/**
如果此Class是在另一个类中声明的，则返回表示在其中声明它的类的Class对象。
如果此类或接口不是任何其他类的成员，则此方法返回null。
如果此Class表示数组类、原始类型或void，则此方法返回null。
**/
public Class<?> getDeclaringClass(){...}
/**
返回定义此匿名类的方法、构造方法、或类 <https://blog.csdn.net/liuxiao723846/article/details/54668820>
**/
public Method getEnclosingMethod(){...}
public Constructor<?> getEnclosingConstructor(){...}
public Class<?> getEnclosingClass() {...}

/**
返回在此类中定义的内部类
或者如果此Class表示原始类型、数组类或void，则此方法返回长度为0的数组。
**/
public Class<?>[] getDeclaredClasses(){...}
public Class<?>[] getClasses(){...}

/**
如果此Class是在非static类、方法、块中声明的，则parameterTypes的第一个参数是声明了此Class的实例对象。
**/
public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes){...}
public Constructor<T> getConstructor(Class<?>... parameterTypes) {...}

/**
返回的数组中的元素没有排序，也没有任何特定的顺序。
如果该类具有默认构造函数，则它包含在返回的数组中。
如果此Class对象表示接口、原始类型、数组类型或void，则此方法返回长度为0的数组。
**/
public Constructor<?>[] getDeclaredConstructors()

/**
如果类没有公共构造函数，或者类是数组类，或者原始类型或void，则返回长度为0的数组。
请注意，虽然此方法返回一个Constructor<T> 对象数组（即此类的构造函数数组），但此方法的返回类型可能是Constructor<?>[]而不是Constructor<T>[]是预期的。
这种信息量较少的返回类型是必要的，可以同时聚合保存不同类的Constructor对象。
**/
public Constructor<?>[] getConstructors() {...}

/**
此方法**无法找到**数组类型中的length属性。
**/
public Field getDeclaredField(String name){...}
public Field getField(String name){...}

/**
如果此Class表示数组类型、原始类型或 void，则此方法返回长度为0的数组。
返回数组中的元素没有排序，也没有任何特定的顺序
**/
public Field[] getDeclaredFields() {...}
public Field[] getFields(){...}

/**
如果名称是“<init>”或“<clinit>”，则会引发NoSuchMethodException。
如果在一个类中声明了多个具有相同参数类型的方法（Java不允许，但JVM允许），并且其中一个方法的返回类型比其他任何方法都更具体，则返回该方法；否则任意选择其中一种方法。
如果此Class代表一个数组类型，那么这个方法找不到clone()方法。
不包含**静态方法**
**/
public Method getDeclaredMethod(String name, Class<?>... parameterTypes){...}
public Method getMethod(String name, Class<?>... parameterTypes){...}

/**
返回的方法中不包含“<clinit>”方法
如果此Class表示数组类型、原始类型或void，则返回的数组的长度为0。
返回数组中的元素没有排序，也没有任何特定的顺序。
**/
public Method[] getDeclaredMethods(){...}

/**
如果此Class表示一个数组类型，则返回从Object继承的公共方法。但它不包含clone。
如果此Class表示一个接口，则返回的数组不包含任何来自Object的隐式声明的方法。因此，如果在此接口或其任何超接口中没有显式声明任何方法，则返回的数组的长度为0。（请注意，表示类的Class始终具有从Object继承的公共方法。）
**/
public Method[] getMethods() {...}

/**
获取注解，从父类继承来的注解，以及注解继承的父注解.
详见[注解](https://docs.oracle.com/javase/8/docs/api/java/lang/reflect/AnnotatedElement.html)
**/
public <A extends Annotation> A getDeclaredAnnotation(Class<A> annotationClass){...}
public <A extends Annotation> A[] getDeclaredAnnotationsByType(Class<A> annotationClass){...}
public Annotation[] getDeclaredAnnotations(){...}
public <A extends Annotation> A getAnnotation(Class<A> annotationClass){...}
public <A extends Annotation> A[] getAnnotationsByType(Class<A> annotationClass){...}
public Annotation[] getAnnotations(){...}
public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass){...}

/**
使用该类的加载器获取指定资源，如果资源以"/"开头，则资源相对于CLASSPATH的绝对路径。否则是基于该类所在包的相对路径。
**/
public InputStream getResourceAsStream(String name){...}
public java.net.URL getResource(String name){...}

/**
与instanceof等效。失败抛出ClassCastException。
如果此Class表示原始类型，则此方法永远返回false（int.class.isInstance(2)==false）。
**/
public native boolean isInstance(Object obj);

public native boolean isAssignableFrom(Class<?> cls); //判断参数是否与此Class相同，或是子类
public native boolean isInterface(); //判断是否是接口类
public native boolean isArray();    //是否是数组类
public native boolean isPrimitive(); //否是原始数据类型
public boolean isEnum(){...}  //是否是枚举类型
public boolean isAnnotation() {...} //判断是否是注解类型，如果此方法返回true，则isInterface也返回true。
public boolean isSynthetic() {...} //判断此类是否是[合成类](https://juejin.cn/post/6850418111481544717)
public boolean isAnonymousClass() {...} //判断是否是匿名类
public boolean isLocalClass(){...}  //判断是否是本地类
public boolean isMemberClass() {...} //判断是否是成员类

public Package getPackage(){...} //返回此类所属的包对象
public ClassLoader getClassLoader() {...} //返回加载此Class的ClassLoader。如果由引导类加载器加载则返回null。
public TypeVariable<Class<T>>[] getTypeParameters(){...} //如果是模板类，获取泛型类型参数，详解后文
public native Class<? super T> getSuperclass(); //返回此Class的超类。如果此Class表示Object类、接口、原始类型或void，则返回null。如果此对象表示数组类，则返回Object类。
static native Class<?> getPrimitiveClass(String name); //返回指定原始类型的Class
public T[] getEnumConstants(){...} //返回枚举类型的所有枚举
public T cast(Object obj) {...}  //将对象强制转换为此Class表示的类或接口。
public <U> Class<? extends U> asSubclass(Class<U> clazz) {...} //强制转换为指定的子类，失败抛出 ClassCastException。
public Type[] getGenericInterfaces(){...} //获取所有实现的接口Type类型，可以用于获取泛型接口。
public native Class<?> getComponentType(); //如果是数组返回其组件类型。否则返回null。

interface Demo21{}
interface Demo22{}

public Class Demo<T1,T2 extends Integer,T3 extends Demo21 & Demo22>{}

TypeVariable<Class> [] typeParameters = Demo1.class.getTypeParameters();
for(TypeVariable<Class> typeParameter:typeParameters){
   System.out.println("变量名称:"+typeParameter.getName());
   System.out.println("这个变量在哪声明的:"+typeParameter.getGenericDeclaration());
   Type[]bounds = typeParameter.getBounds();
   System.out.println("这个变量上边界数量:"+bounds.length);
   System.out.println("这个变量上边界清单:");
   for (Type bound : bounds) {
      System.out.println(bound.getTypeName());
   }
}
/**输出
变量名称:T1
这个变量在哪声明的:class com.test.Demo1
这个变量上边界数量:1
这个变量上边界清单:java.lang.Object
变量名称:T2
这个变量在哪声明的:class com.test.Demo1
这个变量上边界数量:1
这个变量上边界清单:java.lang.Integer
变量名称:T3
这个变量在哪声明的:class com.test.Demo1
这个变量上边界数量:2
这个变量上边界清单:
com.test.Demo21
com.test.Demo22
**/

//初始化System类的方法
private static void initializeSystemClass(){...}

//返回当前时间，单位（毫秒）。其分辨率粒度取决于底层操作系统。有操作系统以几十毫秒为单位测量时间。
public static native long currentTimeMillis();
/**
返回当前时间，单位（纳秒）。此方法提供纳秒精度但不提供纳秒分辨率，也就是说其分辨率不一定比currentTimeMillis高。
292年2^63纳秒可能会造成数值溢出。比较两个时间时应该使用减法计算，而不是比较符号，因为数值可能会溢出。
**/
public static native long nanoTime();
/**
只支持数组类型，且具有相同的组件类型进行拷贝。特别的，不支持组件的原始类型和包装类型之间进行拷贝。不然会抛出ArrayStoreException。
不支持扩容操作，所以任何长度计算出错或长度不够都会抛出IndexOutOfBoundsException。
当复制过程中发生ArrayStoreException时，会停止复制，但不影响已复制数据。
**/
public static native void arraycopy(Object src,  int  srcPos, Object dest, int destPos, int length);

//hashCode方法可以被重写，identityHashCode会根据内存地址返回对象的hash值而不管对象是否重写了hashCode方法。
public static native int identityHashCode(Object x);

//系统换行符。在UNIX系统中是"\n"，在windows中是"\r\n"
private static String lineSeparator;
public static String lineSeparator() {...}

//见下文系统属性列表
private static Properties props;
public static String getProperty(String key){...}
public static String getProperty(String key, String def){...}
public static Properties getProperties(){...}
public static String setProperty(String key, String value)
public static void setProperties(Properties props){...}
private static native Properties initProperties(Properties props);
public static String clearProperty(String key){...}

/**
系统属性和环境变量在概念上都是名称和值之间的映射。这两种机制都可用于将用户定义的信息传递给Java进程。
环境变量具有更全局的影响，因为它们对定义它们的进程的所有后代可见，而不仅仅是直接的Java子进程。
在不同的操作系统上，它们可能具有细微的不同语义，例如不区分大小写。由于这些原因，环境变量更有可能产生意想不到的副作用。
最好尽可能使用系统属性。当需要全局效果或外部系统接口需要环境变量（例如 PATH）时，应使用环境变量。

在 UNIX 系统上，名称的字母大小写通常很重要，而在Windows系统上通常不重要。
例如，表达式 System.getenv("FOO").equals(System.getenv("foo")) 在Windows上可能为真。
**/
public static String getenv(String name){...}
public static java.util.Map<String,String> getenv(){...}

//终止当前运行的Java虚拟机。参数用作状态码；非零状态码表示异常终止。
public static void exit(int status) {
   Runtime.getRuntime().exit(status);
}
//尝试运行垃圾收集器。
public static void gc() {
   Runtime.getRuntime().gc();
}
//尝试运行任何等待清理的对象的终结方法。
public static void runFinalization() {
   Runtime.getRuntime().runFinalization();
}
//已弃用，不安全，可能会多个线程同时操作一个对象
@Deprecated
public static void runFinalizersOnExit(boolean value) {
   Runtime.runFinalizersOnExit(value);
}
//加载JNI库，单个文件，不自动查找依赖
public static void load(String filename) {
   Runtime.getRuntime().load0(Reflection.getCallerClass(), filename);
}
//加载JNI库，从java.library.path中自动查找依赖
public static void loadLibrary(String libname) {
   Runtime.getRuntime().loadLibrary0(Reflection.getCallerClass(), libname);
}
//将库名称映射到表示本机库的特定于平台的字符串。
public static native String mapLibraryName(String libname);

public final static InputStream in = null;
public final static PrintStream out = null;
public final static PrintStream err = null;
private static volatile SecurityManager security = null;
private static volatile Console cons = null;

public static void setIn(InputStream in){...}
private static native void setIn0(InputStream in);
public static void setOut(PrintStream out){...}
private static native void setOut0(PrintStream out);
public static void setErr(PrintStream err){...}
private static native void setErr0(PrintStream err);
public static SecurityManager getSecurityManager(){...}
public static void setSecurityManager(final SecurityManager s){...}
private static synchronized void setSecurityManager0(final SecurityManager s){...}
public static Console console(){...}
public static Channel inheritedChannel(){...}

/**
启动关闭流程。第一阶段并行且随机运行所有的shutdown hooks。第二阶段，运行所有注册过finalizationOnExit流程。
如果在JVM已经进入关闭流程后调用此方法，会进入阻塞。
**/
public void exit(int status){
   Shutdown.exit(status);
}
/**
添加一个未start的线程。一旦进入shutdown hook流程只能调用halt方法来强制停止虚拟机。
JVM关闭流程开始后无法添加和移除hook。hook并不可信，不能完全依赖。
不要再hook中进行长时间操作。
**/
public void addShutdownHook(Thread hook) {
   ApplicationShutdownHooks.add(hook);
}
public boolean removeShutdownHook(Thread hook) {
   return ApplicationShutdownHooks.remove(hook);
}
//不进入任何流程，直接强制关闭JVM
public void halt(int status) {
   Shutdown.beforeHalt();
   Shutdown.halt(status);
}
@Deprecated
public static void runFinalizersOnExit(boolean value) {
   Shutdown.setRunFinalizersOnExit(value);
}

// +5重载
public Process exec(String[] cmdarray, String[] envp, File dir) throws IOException {
   return new ProcessBuilder(cmdarray)
      .environment(envp)
      .directory(dir)
      .start();
}
/**
返回JVM可用的处理器数量。
此值可能会在虚拟机的特定调用期间发生变化。因此，对可用处理器数量敏感的应用程序应偶尔轮询此属性并适当调整其资源使用情况。
**/
public native int availableProcessors();

//返回JVM中可用内存量。调用gc方法可能会导致值增加。
public native long freeMemory();
/**
返回JVM中的内存总量。此方法返回的值可能会随时间变化，具体取决于主机环境。
请注意，保存任何给定类型的对象所需的内存量可能取决于实现。
**/
public native long totalMemory();

//返回JVM将尝试使用的最大内存量。如果没有固有限制，则返回Long.MAX_VALUE值。
public native long maxMemory();

//建议JVM进行垃圾回收
public native void gc();

//尝试运行JVM中对象的终结方法
private static native void runFinalization0();
public void runFinalization() {
   runFinalization0();
}
/**
启用/禁用指令跟踪。如果布尔参数为真，则此方法建议 Java 虚拟机在执行时为虚拟机中的每条指令发出调试信息。此信息的格式以及将其发送到的文件或其他输出流取决于主机环境。如果虚拟机不支持此功能，它可能会忽略此请求。跟踪输出的目的地取决于系统。
如果布尔参数为假，此方法会导致虚拟机停止执行它正在执行的详细指令跟踪。
**/
public native void traceInstructions(boolean on);
/**
启用/禁用方法调用的跟踪。如果布尔参数为真，则此方法建议 Java 虚拟机在调用虚拟机时为虚拟机中的每个方法发出调试信息。此信息的格式以及将其发送到的文件或其他输出流取决于主机环境。如果虚拟机不支持此功能，它可能会忽略此请求。
使用参数 false 调用此方法表明虚拟机停止发出每次调用的调试信息。
**/
public native void traceMethodCalls(boolean on);

public void load(String filename){
   load0(Reflection.getCallerClass(), filename);
}
synchronized void load0(Class<?> fromClass, String filename){
   ClassLoader.loadLibrary(fromClass, filename, true);
}

public void loadLibrary(String libname) {
   loadLibrary0(Reflection.getCallerClass(), libname);
}
synchronized void loadLibrary0(Class<?> fromClass, String libname) {
   ClassLoader.loadLibrary(fromClass, libname, false);
}

class ApplicationShutdownHooks {
    private static IdentityHashMap<Thread, Thread> hooks;
    static {
        try {
            Shutdown.add(1 /* 注册位置 */,
                false /* 如果JVM正在退出则不进行注册 */,
                new Runnable() {
                    public void run() {
                        runHooks();
                    }
                }
            );
            hooks = new IdentityHashMap<>();
        } catch (IllegalStateException e) {
            //当JVM正在退出时，用户无法注册回调
            hooks = null;
        }
    }


    private ApplicationShutdownHooks() {}

    static synchronized void add(Thread hook) {
        if(hooks == null)
            throw new IllegalStateException("Shutdown in progress");

        if (hook.isAlive())
            throw new IllegalArgumentException("Hook already running");

        if (hooks.containsKey(hook))
            throw new IllegalArgumentException("Hook previously registered");

        hooks.put(hook, hook);
    }

    static synchronized boolean remove(Thread hook) {
        if(hooks == null)
            throw new IllegalStateException("Shutdown in progress");

        if (hook == null)
            throw new NullPointerException();

        return hooks.remove(hook) != null;
    }

    static void runHooks() {
        Collection<Thread> threads;
        synchronized(ApplicationShutdownHooks.class) {
            threads = hooks.keySet();
            hooks = null;
        }

        for (Thread hook : threads) {
            hook.start();
        }
        for (Thread hook : threads) {
            while (true) {
                try {
                    hook.join();
                    break;
                } catch (InterruptedException ignored) {
                }
            }
        }
    }
}

class Shutdown {

    /* 状态常量 */
    private static final int RUNNING = 0;
    private static final int HOOKS = 1;
    private static final int FINALIZERS = 2;
    private static int state = RUNNING;

    private static boolean runFinalizersOnExit = false;
    private static int currentRunningHook = 0;

    /** 系统定义的回调，保存在hooks属性的预定位置
        [0] Console restore hook （目前还不知道其作用）
        [1] Application hooks （ApplicationShutdownHooks是往这一位注册）
        [2] DeleteOnExit hook  （在File.deleteOnExit方法中使用，用于退出时清理临时文件）
    **/ 
    private static final int MAX_SYSTEM_HOOKS = 10;
    private static final Runnable[] hooks = new Runnable[MAX_SYSTEM_HOOKS];

    private static class Lock { };
    private static Object lock = new Lock();
    private static Object haltLock = new Lock();

    //Runtime.runFinalizersOnExit最终调用到这里
    static void setRunFinalizersOnExit(boolean run) {
        synchronized (lock) {
            runFinalizersOnExit = run;
        }
    }

    static void add(int slot, boolean registerShutdownInProgress, Runnable hook) {
        synchronized (lock) {
            if (hooks[slot] != null)
                throw new InternalError("Shutdown hook at slot " + slot + " already registered");

            if (!registerShutdownInProgress) {
                if (state > RUNNING)
                    throw new IllegalStateException("Shutdown in progress");
            } else {
                if (state > HOOKS || (state == HOOKS && slot <= currentRunningHook))
                    throw new IllegalStateException("Shutdown in progress");
            }

            hooks[slot] = hook;
        }
    }

    private static void runHooks() {
        for (int i=0; i < MAX_SYSTEM_HOOKS; i++) {
            try {
                Runnable hook;
                synchronized (lock) {//此处用锁是为了确保能够感知到在退出过程中注册的回调
                    currentRunningHook = i;
                    hook = hooks[i];
                }
                if (hook != null) hook.run();
            } catch(Throwable t) {
                if (t instanceof ThreadDeath) {
                    ThreadDeath td = (ThreadDeath)t;
                    throw td;
                }
            }
        }
    }

    //通知JVM
    static native void beforeHalt();

    //此处加锁以避免破坏“在关闭时删除”文件列表。
    static void halt(int status) {
        synchronized (haltLock) {
            halt0(status);
        }
    }

    static native void halt0(int status);

    /* Wormhole for invoking java.lang.ref.Finalizer.runAllFinalizers */
    private static native void runAllFinalizers();

    //运行预定义的关闭流程
    private static void sequence() {
        synchronized (lock) {
            //防止守护线程在DestroyJavaVM启动关闭序列后调用exit
            if (state != HOOKS) return;
        }
        runHooks();
        boolean rfoe;
        synchronized (lock) {
            state = FINALIZERS;
            rfoe = runFinalizersOnExit;
        }
        if (rfoe) runAllFinalizers();
    }


    /**
    在Runtime.exit或中断退出状态回调中被调用。
    **/
    static void exit(int status) {
        boolean runMoreFinalizers = false;
        synchronized (lock) {
            if (status != 0) runFinalizersOnExit = false;
            switch (state) {
            case RUNNING:       /* Initiate shutdown */
                state = HOOKS;
                break;
            case HOOKS:         /* Stall and halt */
                break;
            case FINALIZERS:
                if (status != 0) {
                    //在非零状态下立即停止
                    halt(status);
                } else {
                    //与旧行为的兼容性:运行更多终结器，然后停止
                    runMoreFinalizers = runFinalizersOnExit;
                }
                break;
            }
        }
        if (runMoreFinalizers) {
            runAllFinalizers();
            halt(status);
        }
        synchronized (Shutdown.class) {
            //同步类对象，导致试图启动shutdown的任何其他线程无限期地停止
            beforeHalt();
            sequence();
            halt(status);
        }
    }

    //当最后一个非守护线程结束时，由JNI DestroyJavaVM过程调用。与exit方法不同，这个方法实际上并不会停止VM。
    static void shutdown() {
        synchronized (lock) {
            switch (state) {
            case RUNNING:       /* Initiate shutdown */
                state = HOOKS;
                break;
            case HOOKS:         /* Stall and then return */
            case FINALIZERS:
                break;
            }
        }
        synchronized (Shutdown.class) {
            sequence();
        }
    }

}

private static SignalHandler handler = null;

    static void setup() {
        if (handler != null) return;
        SignalHandler sh = new SignalHandler() {
            public void handle(Signal sig) {
                Shutdown.exit(sig.getNumber() + 0200);
            }
        };
        handler = sh;
        try {
            Signal.handle(new Signal("HUP"), sh);
        } catch (IllegalArgumentException e) {
        }
        try {
            Signal.handle(new Signal("INT"), sh);
        } catch (IllegalArgumentException e) {
        }
        try {
            Signal.handle(new Signal("TERM"), sh);
        } catch (IllegalArgumentException e) {
        }
    }
}

public final class Compiler  {
    public static native boolean compileClass(Class<?> clazz);
    public static native boolean compileClasses(String string);
    public static native Object command(Object any);
    public static native void enable();
    public static native void disable();
}

class AssertionStatusDirectives {
    String[] classes;
    boolean[] classEnabled;

    String[] packages;
    boolean[] packageEnabled;

    //默认情况下，是否启用非系统类中的断言。
    boolean deflt;
}

public final class RuntimePermission extends BasicPermission {

    public RuntimePermission(String name) {
        super(name);
    }

    public RuntimePermission(String name, String actions) {
        super(name, actions);
    }
}

SecurityManager security = System.getSecurityManager();
if (security != null) {
    security.checkXXX(argument,...);
}

Object context = null;
SecurityManager sm = System.getSecurityManager();
if (sm != null) context = sm.getSecurityContext();

//另一个线程
if (sm != null) sm.checkPermission(permission, context);