java System 解析

jdk 源码简单分析

package java.lang;

import java.io.*;
import java.security.AccessControlContext;
import java.util.Properties;
import java.util.PropertyPermission;
import java.util.StringTokenizer;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.AllPermission;
import java.nio.channels.Channel;
import java.nio.channels.spi.SelectorProvider;
import sun.nio.ch.Interruptible;
import sun.reflect.CallerSensitive;
import sun.reflect.Reflection;
import sun.security.util.SecurityConstants;
import sun.reflect.annotation.AnnotationType;

public final class System {

/* 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();
}

private System() {
}
/* “标准”输入流*/
public final static InputStream in = null;
/* “标准”输出流*/
public final static PrintStream out = null;
/*“标准”错误输出流*/
public final static PrintStream err = null;

/* The security manager for the system.*/
private static volatile SecurityManager security = null;

public static void setIn(InputStream in) {
checkIO();
setIn0(in);
}
public static void setOut(PrintStream out) {
checkIO();
setOut0(out);
}
public static void setErr(PrintStream err) {
checkIO();
setErr0(err);
}

private static volatile Console cons = null;
/*
* 返回与当前 Java 虚拟机关联的唯一 Console 对象（如果有）
* 一般指控制台
*/
public static Console console() {
if (cons == null) {
synchronized (System.class) {
cons = sun.misc.SharedSecrets.getJavaIOAccess().console();
}
}
return cons;
}

/*返回从创建此 Java 虚拟机的实体中继承的信道。*/
public static Channel inheritedChannel() throws IOException {
return SelectorProvider.provider().inheritedChannel();
}

private static void checkIO() {
SecurityManager sm = getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("setIO"));
}
}
private static native void setIn0(InputStream in);
private static native void setOut0(PrintStream out);
private static native void setErr0(PrintStream err);

/* 设置系统安全性 */
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;
}

/* 获取系统安全接口 */
public static SecurityManager getSecurityManager() {
return security;
}

/*获得当前系统时间的毫秒数*/
public static native long currentTimeMillis();

/* 返回最准确的可用系统计时器的当前值，以毫微秒为单位。 */
public static native long nanoTime();

/*  从指定源数组中复制一个数组，复制从指定的位置开始，到目标数组的指定位置结束。 */
public static native void arraycopy(Object src,  int  srcPos,
Object dest, int destPos,
int length);

/* 返回给定对象的哈希码，该代码与默认的方法 hashCode() 返回的代码一样，无论给定对象的类是否重写 hashCode()。 */
public static native int identityHashCode(Object x);

private static Properties props;
private static native Properties initProperties(Properties props);

/* 确定当前的系统属性。(所有的属性)*/
public static Properties getProperties() {
SecurityManager sm = getSecurityManager();
if (sm != null) {
sm.checkPropertiesAccess();
}

return props;
}

/*
* since jdk1.7
* 返回系统相关的行分隔符字符串。它总是返回相同的值的初始值的{ @ linkplain # getProperty（String）系统属性} { @code line.separator}。
* 在UNIX系统上，它返回{ @code "\n"}；在微软Windows系统返回{ @code "\r\n"}。
*/
public static String lineSeparator() {
return lineSeparator;
}

private static String lineSeparator;
/* 将系统属性设置为 Properties 参数。 */
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;
}
/* 获取指定键指示的系统属性。*/
public static String getProperty(String key) {
checkKey(key);
SecurityManager sm = getSecurityManager();
if (sm != null) {
sm.checkPropertyAccess(key);
}

return props.getProperty(key);
}

/*  获取用指定键描述的系统属性。 */
public static String getProperty(String key, String def) {
checkKey(key);
SecurityManager sm = getSecurityManager();
if (sm != null) {
sm.checkPropertyAccess(key);
}

return props.getProperty(key, def);
}

/* 设置指定键指示的系统属性。 */
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);
}

/*  移除指定键指示的系统属性。 */
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");
}
}

/* 获取指定的环境变量值。 */
public static String getenv(String name) {
SecurityManager sm = getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("getenv."+name));
}

return ProcessEnvironment.getenv(name);
}

/* 返回一个不能修改的当前系统环境的字符串映射视图。 */
public static java.util.Map<String,String> getenv() {
SecurityManager sm = getSecurityManager();
if (sm != null) {
sm.checkPermission(new RuntimePermission("getenv.*"));
}

return ProcessEnvironment.getenv();
}

/* 终止当前正在运行的 Java 虚拟机 */
public static void exit(int status) {
Runtime.getRuntime().exit(status);
}

/*
* 调用 gc 方法暗示着Java虚拟机做了一些努力来回收未用对象，以便能够快速地重用这些对象当前占用的内存。
*  当控制权从方法调用中返回时，虚拟机已经尽最大努力从所有丢弃的对象中回收了空间。
*/
public static void gc() {
Runtime.getRuntime().gc();
}

/*
* 调用该方法说明 Java 虚拟机做了一些努力运行已被丢弃对象的 finalize 方法，但是这些对象的 finalize 方法至今尚未运行。
* 当控制权从方法调用中返回时，Java 虚拟机已经尽最大努力去完成所有未执行的终止方法。
*/
public static void runFinalization() {
Runtime.getRuntime().runFinalization();
}

@Deprecated
public static void runFinalizersOnExit(boolean value) {
Runtime.getRuntime().runFinalizersOnExit(value);
}

/*从作为动态库的本地文件系统中以指定的文件名加载代码文件。文件名参数必须是完整的路径名。*/
@CallerSensitive
public static void load(String filename) {
Runtime.getRuntime().load0(Reflection.getCallerClass(), filename);
}

/*加载由 libname 参数指定的系统库。将库名映射到实际系统库的方法取决于系统。*/
@CallerSensitive
public static void loadLibrary(String libname) {
Runtime.getRuntime().loadLibrary0(Reflection.getCallerClass(), libname);
}

/* 将一个库名称映射到特定于平台的、表示本机库的字符串中。 */
public static native String mapLibraryName(String libname);

/**
* 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(new PrintStream(new BufferedOutputStream(fdOut, 128), true));
setErr0(new PrintStream(new BufferedOutputStream(fdErr, 128), true));
// 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 void setAnnotationType(Class klass, AnnotationType type) {
klass.setAnnotationType(type);
}
public AnnotationType getAnnotationType(Class klass) {
return klass.getAnnotationType();
}
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 int getStringHash32(String string) {
return string.hash32();
}
public Thread newThreadWithAcc(Runnable target, AccessControlContext acc) {
return new Thread(target, acc);
}
public void invokeFinalize(Object o) throws Throwable {
o.finalize();
}
});
}
}

该类主要是与操作系统的交互

1.可以实现获得系统的配置的各类参数

2.得到和设置标准的输入输出流

3.实现内存级别的Array copy (clone) (*)

4.JNI的加载

5.虚拟机的内存管理（主要是通过Runtime.getRuntime()来实现的）