- 通过每块代码进行源码解读，并发现源码使用的技术栈，扩展视野。
- registerNatives 方法解读
/* register the natives via the static initializer. * * VM will invoke the initializeSystemClass method to complete * the initialization for this class separated from clinit. * Note that to use properties set by the VM, see the constraints * described in the initializeSystemClass method. */ private static native void registerNatives(); static { registerNatives(); }关键字: native，这涉及【JNI】的一些概念。简单理解就是"定义的方法并不是用java实现的，而是由系统连接的共享库实现"。
- System是不能实例化的类
/** Don't let anyone instantiate this class */private System() { } - System的标准输入输出的初始化问题简单理解就是由系统连接的共享库去实现的。定义的三个IO流，都是final修饰符，所以即使是public 也是不能重新赋值。
public final static InputStream in = null; public final static PrintStream out = null;
public final static PrintStream err = null;private static native void setIn0(InputStream in);
private static native void setOut0(PrintStream out);
private static native void setErr0(PrintStream err); - 关于java.lang.SecurityManager
/** * The security manager for the system. */ private static volatile SecurityManager security = null; private static void checkIO() { SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPermission(new RuntimePermission("setIO")); } } public static void setSecurityManager(final SecurityManager s) { try { s.checkPackageAccess("java.lang"); } catch (Exception e) { // no-op } setSecurityManager0(s); } private static synchronized void setSecurityManager0(final SecurityManager s) { SecurityManager sm = getSecurityManager(); if (sm != null) { // ask the currently installed security manager if we // can replace it. sm.checkPermission(new RuntimePermission("setSecurityManager")); } if ((s != null) && (s.getClass().getClassLoader() != null)) { // New security manager class is not on bootstrap classpath. // Cause policy to get initialized before we install the new // security manager, in order to prevent infinite loops when // trying to initialize the policy (which usually involves // accessing some security and/or system properties, which in turn // calls the installed security manager's checkPermission method // which will loop infinitely if there is a non-system class // (in this case: the new security manager class) on the stack). AccessController.doPrivileged(new PrivilegedAction<Object>() { public Object run() { s.getClass().getProtectionDomain().implies(SecurityConstants.ALL_PERMISSION); return null; } }); } security = s; } /** * Gets the system security interface. * * @return if a security manager has already been established for the current * application, then that security manager is returned; otherwise, * <code>null</code> is returned. * @see #setSecurityManager */ public static SecurityManager getSecurityManager() { return security; }System类定义了安全管理器，并且【volatile】修饰该变量。在初始化IO流时，需要使用安全器校验权限，具体可另外看【SecurityManager】权限实现。
- 控制台定义console
private static volatile Console cons = null; /** * Returns the unique {@link java.io.Console Console} object associated * with the current Java virtual machine, if any. * * @return The system console, if any, otherwise <tt>null</tt>. * * @since 1.6 */ public static Console console() { if (cons == null) { synchronized (System.class) { cons = sun.misc.SharedSecrets.getJavaIOAccess().console(); } } return cons; }System中的console是通过【sun.misc.SharedSecrets】类获取得到的。关于SharedSecrets类这里只能简单说是关于jvm的。
- 获取系统时间方法currentTimeMillis和nanoTime
/** * 获取毫秒级的时间戳(1970年1月1日0时起的毫秒数) */ public static native long currentTimeMillis(); /** * 获取纳秒，返回的可能是任意时间（主要用于衡量时间段） */ public static native long nanoTime();从native也可知晓，两个方法都是用共享库实现的。
- arraycopy方法
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);该复制为浅复制，即对象数组，只复制对象引用。
- identityHashCode 返回对象地址方法
/** * Returns the same hash code for the given object as * would be returned by the default method hashCode(), * whether or not the given object's class overrides * hashCode(). * The hash code for the null reference is zero. * * @param x object for which the hashCode is to be calculated * @return the hashCode * @since JDK1.1 */ public static native int identityHashCode(Object x);获取对象地址方法有System.identityHashCode(Object)与object.hashCode(),但是由于object的hashCode方法往往会被重写，所以hashCode就不能得到对象地址。
- System properties
/** * System properties. The following properties are guaranteed to be defined: * <dl> * <dt>java.version <dd>Java version number * <dt>java.vendor <dd>Java vendor specific string * <dt>java.vendor.url <dd>Java vendor URL * <dt>java.home <dd>Java installation directory * <dt>java.class.version <dd>Java class version number * <dt>java.class.path <dd>Java classpath * <dt>os.name <dd>Operating System Name * <dt>os.arch <dd>Operating System Architecture * <dt>os.version <dd>Operating System Version * <dt>file.separator <dd>File separator ("/" on Unix) * <dt>path.separator <dd>Path separator (":" on Unix) * <dt>line.separator <dd>Line separator ("\n" on Unix) * <dt>user.name <dd>User account name * <dt>user.home <dd>User home directory * <dt>user.dir <dd>User's current working directory * </dl> */ private static Properties props; private static native Properties initProperties(Properties props); /** * Determines the current system properties. * <p> * First, if there is a security manager, its * <code>checkPropertiesAccess</code> method is called with no * arguments. This may result in a security exception. * <p> * The current set of system properties for use by the * {@link #getProperty(String)} method is returned as a * <code>Properties</code> object. If there is no current set of * system properties, a set of system properties is first created and * initialized. This set of system properties always includes values * for the following keys: * <table summary="Shows property keys and associated values"> * <tr><th>Key</th> * <th>Description of Associated Value</th></tr> * <tr><td><code>java.version</code></td> * <td>Java Runtime Environment version</td></tr> * <tr><td><code>java.vendor</code></td> * <td>Java Runtime Environment vendor</td></tr> * <tr><td><code>java.vendor.url</code></td> * <td>Java vendor URL</td></tr> * <tr><td><code>java.home</code></td> * <td>Java installation directory</td></tr> * <tr><td><code>java.vm.specification.version</code></td> * <td>Java Virtual Machine specification version</td></tr> * <tr><td><code>java.vm.specification.vendor</code></td> * <td>Java Virtual Machine specification vendor</td></tr> * <tr><td><code>java.vm.specification.name</code></td> * <td>Java Virtual Machine specification name</td></tr> * <tr><td><code>java.vm.version</code></td> * <td>Java Virtual Machine implementation version</td></tr> * <tr><td><code>java.vm.vendor</code></td> * <td>Java Virtual Machine implementation vendor</td></tr> * <tr><td><code>java.vm.name</code></td> * <td>Java Virtual Machine implementation name</td></tr> * <tr><td><code>java.specification.version</code></td> * <td>Java Runtime Environment specification version</td></tr> * <tr><td><code>java.specification.vendor</code></td> * <td>Java Runtime Environment specification vendor</td></tr> * <tr><td><code>java.specification.name</code></td> * <td>Java Runtime Environment specification name</td></tr> * <tr><td><code>java.class.version</code></td> * <td>Java class format version number</td></tr> * <tr><td><code>java.class.path</code></td> * <td>Java class path</td></tr> * <tr><td><code>java.library.path</code></td> * <td>List of paths to search when loading libraries</td></tr> * <tr><td><code>java.io.tmpdir</code></td> * <td>Default temp file path</td></tr> * <tr><td><code>java.compiler</code></td> * <td>Name of JIT compiler to use</td></tr> * <tr><td><code>java.ext.dirs</code></td> * <td>Path of extension directory or directories * <b>Deprecated.</b> <i>This property, and the mechanism * which implements it, may be removed in a future * release.</i> </td></tr> * <tr><td><code>os.name</code></td> * <td>Operating system name</td></tr> * <tr><td><code>os.arch</code></td> * <td>Operating system architecture</td></tr> * <tr><td><code>os.version</code></td> * <td>Operating system version</td></tr> * <tr><td><code>file.separator</code></td> * <td>File separator ("/" on UNIX)</td></tr> * <tr><td><code>path.separator</code></td> * <td>Path separator (":" on UNIX)</td></tr> * <tr><td><code>line.separator</code></td> * <td>Line separator ("\n" on UNIX)</td></tr> * <tr><td><code>user.name</code></td> * <td>User's account name</td></tr> * <tr><td><code>user.home</code></td> * <td>User's home directory</td></tr> * <tr><td><code>user.dir</code></td> * <td>User's current working directory</td></tr> * </table> * <p> * Multiple paths in a system property value are separated by the path * separator character of the platform. * <p> * Note that even if the security manager does not permit the * <code>getProperties</code> operation, it may choose to permit the * {@link #getProperty(String)} operation. * * @return the system properties * @exception SecurityException if a security manager exists and its * <code>checkPropertiesAccess</code> method doesn't allow access * to the system properties. * @see #setProperties * @see java.lang.SecurityException * @see java.lang.SecurityManager#checkPropertiesAccess() * @see java.util.Properties */ public static Properties getProperties() { SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPropertiesAccess(); } return props; } /** * Returns the system-dependent line separator string. It always * returns the same value - the initial value of the {@linkplain * #getProperty(String) system property} {@code line.separator}. * * <p>On UNIX systems, it returns {@code "\n"}; on Microsoft * Windows systems it returns {@code "\r\n"}. * * @return the system-dependent line separator string * @since 1.7 */ public static String lineSeparator() { return lineSeparator; } private static String lineSeparator; /** * Sets the system properties to the <code>Properties</code> * argument. * <p> * First, if there is a security manager, its * <code>checkPropertiesAccess</code> method is called with no * arguments. This may result in a security exception. * <p> * The argument becomes the current set of system properties for use * by the {@link #getProperty(String)} method. If the argument is * <code>null</code>, then the current set of system properties is * forgotten. * * @param props the new system properties. * @exception SecurityException if a security manager exists and its * <code>checkPropertiesAccess</code> method doesn't allow access * to the system properties. * @see #getProperties * @see java.util.Properties * @see java.lang.SecurityException * @see java.lang.SecurityManager#checkPropertiesAccess() */ public static void setProperties(Properties props) { SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPropertiesAccess(); } if (props == null) { props = new Properties(); initProperties(props); } System.props = props; } /** * Gets the system property indicated by the specified key. * <p> * First, if there is a security manager, its * <code>checkPropertyAccess</code> method is called with the key as * its argument. This may result in a SecurityException. * <p> * If there is no current set of system properties, a set of system * properties is first created and initialized in the same manner as * for the <code>getProperties</code> method. * * @param key the name of the system property. * @return the string value of the system property, * or <code>null</code> if there is no property with that key. * * @exception SecurityException if a security manager exists and its * <code>checkPropertyAccess</code> method doesn't allow * access to the specified system property. * @exception NullPointerException if <code>key</code> is * <code>null</code>. * @exception IllegalArgumentException if <code>key</code> is empty. * @see #setProperty * @see java.lang.SecurityException * @see java.lang.SecurityManager#checkPropertyAccess(java.lang.String) * @see java.lang.System#getProperties() */ public static String getProperty(String key) { checkKey(key); SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPropertyAccess(key); } return props.getProperty(key); } /** * Gets the system property indicated by the specified key. * <p> * First, if there is a security manager, its * <code>checkPropertyAccess</code> method is called with the * <code>key</code> as its argument. * <p> * If there is no current set of system properties, a set of system * properties is first created and initialized in the same manner as * for the <code>getProperties</code> method. * * @param key the name of the system property. * @param def a default value. * @return the string value of the system property, * or the default value if there is no property with that key. * * @exception SecurityException if a security manager exists and its * <code>checkPropertyAccess</code> method doesn't allow * access to the specified system property. * @exception NullPointerException if <code>key</code> is * <code>null</code>. * @exception IllegalArgumentException if <code>key</code> is empty. * @see #setProperty * @see java.lang.SecurityManager#checkPropertyAccess(java.lang.String) * @see java.lang.System#getProperties() */ public static String getProperty(String key, String def) { checkKey(key); SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPropertyAccess(key); } return props.getProperty(key, def); } /** * Sets the system property indicated by the specified key. * <p> * First, if a security manager exists, its * <code>SecurityManager.checkPermission</code> method * is called with a <code>PropertyPermission(key, "write")</code> * permission. This may result in a SecurityException being thrown. * If no exception is thrown, the specified property is set to the given * value. * <p> * * @param key the name of the system property. * @param value the value of the system property. * @return the previous value of the system property, * or <code>null</code> if it did not have one. * * @exception SecurityException if a security manager exists and its * <code>checkPermission</code> method doesn't allow * setting of the specified property. * @exception NullPointerException if <code>key</code> or * <code>value</code> is <code>null</code>. * @exception IllegalArgumentException if <code>key</code> is empty. * @see #getProperty * @see java.lang.System#getProperty(java.lang.String) * @see java.lang.System#getProperty(java.lang.String, java.lang.String) * @see java.util.PropertyPermission * @see SecurityManager#checkPermission * @since 1.2 */ public static String setProperty(String key, String value) { checkKey(key); SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPermission(new PropertyPermission(key, SecurityConstants.PROPERTY_WRITE_ACTION)); } return (String) props.setProperty(key, value); } /** * Removes the system property indicated by the specified key. * <p> * First, if a security manager exists, its * <code>SecurityManager.checkPermission</code> method * is called with a <code>PropertyPermission(key, "write")</code> * permission. This may result in a SecurityException being thrown. * If no exception is thrown, the specified property is removed. * <p> * * @param key the name of the system property to be removed. * @return the previous string value of the system property, * or <code>null</code> if there was no property with that key. * * @exception SecurityException if a security manager exists and its * <code>checkPropertyAccess</code> method doesn't allow * access to the specified system property. * @exception NullPointerException if <code>key</code> is * <code>null</code>. * @exception IllegalArgumentException if <code>key</code> is empty. * @see #getProperty * @see #setProperty * @see java.util.Properties * @see java.lang.SecurityException * @see java.lang.SecurityManager#checkPropertiesAccess() * @since 1.5 */ public static String clearProperty(String key) { checkKey(key); SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPermission(new PropertyPermission(key, "write")); } return (String) props.remove(key); } private static void checkKey(String key) { if (key == null) { throw new NullPointerException("key can't be null"); } if (key.equals("")) { throw new IllegalArgumentException("key can't be empty"); } }System定义了系统properties，并且默认初始化了系统相关信息，包含java对应的属性，操作系统的名称，版本等等属性。【Properties】对于属性类，还需要进一步了解。
- 操作系统系统环境变量值
/** * Gets the value of the specified environment variable. An * environment variable is a system-dependent external named * value. * * <p>If a security manager exists, its * {@link SecurityManager#checkPermission checkPermission} * method is called with a * <code>{@link RuntimePermission}("getenv."+name)</code> * permission. This may result in a {@link SecurityException} * being thrown. If no exception is thrown the value of the * variable <code>name</code> is returned. * * <p><a name="EnvironmentVSSystemProperties"><i>System * properties</i> and <i>environment variables</i></a> are both * conceptually mappings between names and values. Both * mechanisms can be used to pass user-defined information to a * Java process. Environment variables have a more global effect, * because they are visible to all descendants of the process * which defines them, not just the immediate Java subprocess. * They can have subtly different semantics, such as case * insensitivity, on different operating systems. For these * reasons, environment variables are more likely to have * unintended side effects. It is best to use system properties * where possible. Environment variables should be used when a * global effect is desired, or when an external system interface * requires an environment variable (such as <code>PATH</code>). * * <p>On UNIX systems the alphabetic case of <code>name</code> is * typically significant, while on Microsoft Windows systems it is * typically not. For example, the expression * <code>System.getenv("FOO").equals(System.getenv("foo"))</code> * is likely to be true on Microsoft Windows. * * @param name the name of the environment variable * @return the string value of the variable, or <code>null</code> * if the variable is not defined in the system environment * @throws NullPointerException if <code>name</code> is <code>null</code> * @throws SecurityException * if a security manager exists and its * {@link SecurityManager#checkPermission checkPermission} * method doesn't allow access to the environment variable * <code>name</code> * @see #getenv() * @see ProcessBuilder#environment() */ public static String getenv(String name) { SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPermission(new RuntimePermission("getenv."+name)); } return ProcessEnvironment.getenv(name); } /** * Returns an unmodifiable string map view of the current system environment. * The environment is a system-dependent mapping from names to * values which is passed from parent to child processes. * * <p>If the system does not support environment variables, an * empty map is returned. * * <p>The returned map will never contain null keys or values. * Attempting to query the presence of a null key or value will * throw a {@link NullPointerException}. Attempting to query * the presence of a key or value which is not of type * {@link String} will throw a {@link ClassCastException}. * * <p>The returned map and its collection views may not obey the * general contract of the {@link Object#equals} and * {@link Object#hashCode} methods. * * <p>The returned map is typically case-sensitive on all platforms. * * <p>If a security manager exists, its * {@link SecurityManager#checkPermission checkPermission} * method is called with a * <code>{@link RuntimePermission}("getenv.*")</code> * permission. This may result in a {@link SecurityException} being * thrown. * * <p>When passing information to a Java subprocess, * <a href=#EnvironmentVSSystemProperties>system properties</a> * are generally preferred over environment variables. * * @return the environment as a map of variable names to values * @throws SecurityException * if a security manager exists and its * {@link SecurityManager#checkPermission checkPermission} * method doesn't allow access to the process environment * @see #getenv(String) * @see ProcessBuilder#environment() * @since 1.5 */ public static java.util.Map<String,String> getenv() { SecurityManager sm = getSecurityManager(); if (sm != null) { sm.checkPermission(new RuntimePermission("getenv.*")); } return ProcessEnvironment.getenv(); }返回的是操作系统的环境变量，并且不可改变。
- System类封装的Runtime方法
/** * Terminates the currently running Java Virtual Machine. The * argument serves as a status code; by convention, a nonzero status * code indicates abnormal termination. * <p> * This method calls the <code>exit</code> method in class * <code>Runtime</code>. This method never returns normally. * <p> * The call <code>System.exit(n)</code> is effectively equivalent to * the call: * <blockquote><pre> * Runtime.getRuntime().exit(n) * </pre></blockquote> * * @param status exit status. * @throws SecurityException * if a security manager exists and its <code>checkExit</code> * method doesn't allow exit with the specified status. * @see java.lang.Runtime#exit(int) */ public static void exit(int status) { Runtime.getRuntime().exit(status); } /** * Runs the garbage collector. * <p> * Calling the <code>gc</code> method suggests that the Java Virtual * Machine expend effort toward recycling unused objects in order to * make the memory they currently occupy available for quick reuse. * When control returns from the method call, the Java Virtual * Machine has made a best effort to reclaim space from all discarded * objects. * <p> * The call <code>System.gc()</code> is effectively equivalent to the * call: * <blockquote><pre> * Runtime.getRuntime().gc() * </pre></blockquote> * * @see java.lang.Runtime#gc() */ public static void gc() { Runtime.getRuntime().gc(); } /** * Runs the finalization methods of any objects pending finalization. * <p> * Calling this method suggests that the Java Virtual Machine expend * effort toward running the <code>finalize</code> methods of objects * that have been found to be discarded but whose <code>finalize</code> * methods have not yet been run. When control returns from the * method call, the Java Virtual Machine has made a best effort to * complete all outstanding finalizations. * <p> * The call <code>System.runFinalization()</code> is effectively * equivalent to the call: * <blockquote><pre> * Runtime.getRuntime().runFinalization() * </pre></blockquote> * * @see java.lang.Runtime#runFinalization() */ public static void runFinalization() { Runtime.getRuntime().runFinalization(); } /** * Enable or disable finalization on exit; doing so specifies that the * finalizers of all objects that have finalizers that have not yet been * automatically invoked are to be run before the Java runtime exits. * By default, finalization on exit is disabled. * * <p>If there is a security manager, * its <code>checkExit</code> method is first called * with 0 as its argument to ensure the exit is allowed. * This could result in a SecurityException. * * @deprecated This method is inherently unsafe. It may result in * finalizers being called on live objects while other threads are * concurrently manipulating those objects, resulting in erratic * behavior or deadlock. * @param value indicating enabling or disabling of finalization * @throws SecurityException * if a security manager exists and its <code>checkExit</code> * method doesn't allow the exit. * * @see java.lang.Runtime#exit(int) * @see java.lang.Runtime#gc() * @see java.lang.SecurityManager#checkExit(int) * @since JDK1.1 */ @Deprecated public static void runFinalizersOnExit(boolean value) { Runtime.runFinalizersOnExit(value); } - java 加载动态库library
@CallerSensitive public static void load(String filename) { Runtime.getRuntime().load0(Reflection.getCallerClass(), filename); } /** */ @CallerSensitive public static void loadLibrary(String libname) { Runtime.getRuntime().loadLibrary0(Reflection.getCallerClass(), libname); } /** * Maps a library name into a platform-specific string representing * a native library. * * @param libname the name of the library. * @return a platform-dependent native library name. * @exception NullPointerException if <code>libname</code> is * <code>null</code> * @see java.lang.System#loadLibrary(java.lang.String) * @see java.lang.ClassLoader#findLibrary(java.lang.String) * @since 1.2 */ public static native String mapLibraryName(String libname); - 初始化Java class
/** * Create PrintStream for stdout/err based on encoding. */ private static PrintStream newPrintStream(FileOutputStream fos, String enc) { if (enc != null) { try { return new PrintStream(new BufferedOutputStream(fos, 128), true, enc); } catch (UnsupportedEncodingException uee) {} } return new PrintStream(new BufferedOutputStream(fos, 128), true); } /** * Initialize the system class. Called after thread initialization. */ private static void initializeSystemClass() { // VM might invoke JNU_NewStringPlatform() to set those encoding // sensitive properties (user.home, user.name, boot.class.path, etc.) // during "props" initialization, in which it may need access, via // System.getProperty(), to the related system encoding property that // have been initialized (put into "props") at early stage of the // initialization. So make sure the "props" is available at the // very beginning of the initialization and all system properties to // be put into it directly. props = new Properties(); initProperties(props); // initialized by the VM // There are certain system configurations that may be controlled by // VM options such as the maximum amount of direct memory and // Integer cache size used to support the object identity semantics // of autoboxing. Typically, the library will obtain these values // from the properties set by the VM. If the properties are for // internal implementation use only, these properties should be // removed from the system properties. // // See java.lang.Integer.IntegerCache and the // sun.misc.VM.saveAndRemoveProperties method for example. // // Save a private copy of the system properties object that // can only be accessed by the internal implementation. Remove // certain system properties that are not intended for public access. sun.misc.VM.saveAndRemoveProperties(props); lineSeparator = props.getProperty("line.separator"); sun.misc.Version.init(); FileInputStream fdIn = new FileInputStream(FileDescriptor.in); FileOutputStream fdOut = new FileOutputStream(FileDescriptor.out); FileOutputStream fdErr = new FileOutputStream(FileDescriptor.err); setIn0(new BufferedInputStream(fdIn)); setOut0(newPrintStream(fdOut, props.getProperty("sun.stdout.encoding"))); setErr0(newPrintStream(fdErr, props.getProperty("sun.stderr.encoding"))); // Load the zip library now in order to keep java.util.zip.ZipFile // from trying to use itself to load this library later. loadLibrary("zip"); // Setup Java signal handlers for HUP, TERM, and INT (where available). Terminator.setup(); // Initialize any miscellenous operating system settings that need to be // set for the class libraries. Currently this is no-op everywhere except // for Windows where the process-wide error mode is set before the java.io // classes are used. sun.misc.VM.initializeOSEnvironment(); // The main thread is not added to its thread group in the same // way as other threads; we must do it ourselves here. Thread current = Thread.currentThread(); current.getThreadGroup().add(current); // register shared secrets setJavaLangAccess(); // Subsystems that are invoked during initialization can invoke // sun.misc.VM.isBooted() in order to avoid doing things that should // wait until the application class loader has been set up. // IMPORTANT: Ensure that this remains the last initialization action! sun.misc.VM.booted(); } private static void setJavaLangAccess() { // Allow privileged classes outside of java.lang sun.misc.SharedSecrets.setJavaLangAccess(new sun.misc.JavaLangAccess(){ public sun.reflect.ConstantPool getConstantPool(Class<?> klass) { return klass.getConstantPool(); } public boolean casAnnotationType(Class<?> klass, AnnotationType oldType, AnnotationType newType) { return klass.casAnnotationType(oldType, newType); } public AnnotationType getAnnotationType(Class<?> klass) { return klass.getAnnotationType(); } public Map<Class<? extends Annotation>, Annotation> getDeclaredAnnotationMap(Class<?> klass) { return klass.getDeclaredAnnotationMap(); } public byte[] getRawClassAnnotations(Class<?> klass) { return klass.getRawAnnotations(); } public byte[] getRawClassTypeAnnotations(Class<?> klass) { return klass.getRawTypeAnnotations(); } public byte[] getRawExecutableTypeAnnotations(Executable executable) { return Class.getExecutableTypeAnnotationBytes(executable); } public <E extends Enum<E>> E[] getEnumConstantsShared(Class<E> klass) { return klass.getEnumConstantsShared(); } public void blockedOn(Thread t, Interruptible b) { t.blockedOn(b); } public void registerShutdownHook(int slot, boolean registerShutdownInProgress, Runnable hook) { Shutdown.add(slot, registerShutdownInProgress, hook); } public int getStackTraceDepth(Throwable t) { return t.getStackTraceDepth(); } public StackTraceElement getStackTraceElement(Throwable t, int i) { return t.getStackTraceElement(i); } public String newStringUnsafe(char[] chars) { return new String(chars, true); } public Thread newThreadWithAcc(Runnable target, AccessControlContext acc) { return new Thread(target, acc); } public void invokeFinalize(Object o) throws Throwable { o.finalize(); } }); }
来源：oschina
链接：https://my.oschina.net/u/4394305/blog/4024794