/*
* Copyright (c) 1994, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.lang;
import java.io.*;
import java.lang.reflect.Executable;
import java.lang.annotation.Annotation;
import java.security.AccessControlContext;
import java.util.Properties;
import java.util.PropertyPermission;
import java.util.StringTokenizer;
import java.util.Map;
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;
import jdk.internal.util.StaticProperty;
The System
class contains several useful class fields
and methods. It cannot be instantiated.
Among the facilities provided by the System
class
are standard input, standard output, and error output streams;
access to externally defined properties and environment
variables; a means of loading files and libraries; and a utility
method for quickly copying a portion of an array.
Author: unascribed Since: JDK1.0
/**
* The <code>System</code> class contains several useful class fields
* and methods. It cannot be instantiated.
*
* <p>Among the facilities provided by the <code>System</code> class
* are standard input, standard output, and error output streams;
* access to externally defined properties and environment
* variables; a means of loading files and libraries; and a utility
* method for quickly copying a portion of an array.
*
* @author unascribed
* @since JDK1.0
*/
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();
}
Don't let anyone instantiate this class /** Don't let anyone instantiate this class */
private System() {
}
The "standard" input stream. This stream is already
open and ready to supply input data. Typically this stream
corresponds to keyboard input or another input source specified by
the host environment or user.
/**
* The "standard" input stream. This stream is already
* open and ready to supply input data. Typically this stream
* corresponds to keyboard input or another input source specified by
* the host environment or user.
*/
public final static InputStream in = null;
The "standard" output stream. This stream is already
open and ready to accept output data. Typically this stream
corresponds to display output or another output destination
specified by the host environment or user.
For simple stand-alone Java applications, a typical way to write
a line of output data is:
System.out.println(data)
See the println
methods in class PrintStream
.
See Also:
/**
* The "standard" output stream. This stream is already
* open and ready to accept output data. Typically this stream
* corresponds to display output or another output destination
* specified by the host environment or user.
* <p>
* For simple stand-alone Java applications, a typical way to write
* a line of output data is:
* <blockquote><pre>
* System.out.println(data)
* </pre></blockquote>
* <p>
* See the <code>println</code> methods in class <code>PrintStream</code>.
*
* @see java.io.PrintStream#println()
* @see java.io.PrintStream#println(boolean)
* @see java.io.PrintStream#println(char)
* @see java.io.PrintStream#println(char[])
* @see java.io.PrintStream#println(double)
* @see java.io.PrintStream#println(float)
* @see java.io.PrintStream#println(int)
* @see java.io.PrintStream#println(long)
* @see java.io.PrintStream#println(java.lang.Object)
* @see java.io.PrintStream#println(java.lang.String)
*/
public final static PrintStream out = null;
The "standard" error output stream. This stream is already
open and ready to accept output data.
Typically this stream corresponds to display output or another
output destination specified by the host environment or user. By
convention, this output stream is used to display error messages
or other information that should come to the immediate attention
of a user even if the principal output stream, the value of the
variable out
, has been redirected to a file or other
destination that is typically not continuously monitored.
/**
* The "standard" error output stream. This stream is already
* open and ready to accept output data.
* <p>
* Typically this stream corresponds to display output or another
* output destination specified by the host environment or user. By
* convention, this output stream is used to display error messages
* or other information that should come to the immediate attention
* of a user even if the principal output stream, the value of the
* variable <code>out</code>, has been redirected to a file or other
* destination that is typically not continuously monitored.
*/
public final static PrintStream err = null;
/* The security manager for the system.
*/
private static volatile SecurityManager security = null;
Reassigns the "standard" input stream.
First, if there is a security manager, its checkPermission
method is called with a RuntimePermission("setIO")
permission
to see if it's ok to reassign the "standard" input stream.
Params: - in – the new standard input stream.
Throws: - SecurityException –
if a security manager exists and its
checkPermission
method doesn't allow
reassigning of the standard input stream.
See Also: Since: JDK1.1
/**
* Reassigns the "standard" input stream.
*
* <p>First, if there is a security manager, its <code>checkPermission</code>
* method is called with a <code>RuntimePermission("setIO")</code> permission
* to see if it's ok to reassign the "standard" input stream.
* <p>
*
* @param in the new standard input stream.
*
* @throws SecurityException
* if a security manager exists and its
* <code>checkPermission</code> method doesn't allow
* reassigning of the standard input stream.
*
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
*
* @since JDK1.1
*/
public static void setIn(InputStream in) {
checkIO();
setIn0(in);
}
Reassigns the "standard" output stream.
First, if there is a security manager, its checkPermission
method is called with a RuntimePermission("setIO")
permission
to see if it's ok to reassign the "standard" output stream.
Params: - out – the new standard output stream
Throws: - SecurityException –
if a security manager exists and its
checkPermission
method doesn't allow
reassigning of the standard output stream.
See Also: Since: JDK1.1
/**
* Reassigns the "standard" output stream.
*
* <p>First, if there is a security manager, its <code>checkPermission</code>
* method is called with a <code>RuntimePermission("setIO")</code> permission
* to see if it's ok to reassign the "standard" output stream.
*
* @param out the new standard output stream
*
* @throws SecurityException
* if a security manager exists and its
* <code>checkPermission</code> method doesn't allow
* reassigning of the standard output stream.
*
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
*
* @since JDK1.1
*/
public static void setOut(PrintStream out) {
checkIO();
setOut0(out);
}
Reassigns the "standard" error output stream.
First, if there is a security manager, its checkPermission
method is called with a RuntimePermission("setIO")
permission
to see if it's ok to reassign the "standard" error output stream.
Params: - err – the new standard error output stream.
Throws: - SecurityException –
if a security manager exists and its
checkPermission
method doesn't allow
reassigning of the standard error output stream.
See Also: Since: JDK1.1
/**
* Reassigns the "standard" error output stream.
*
* <p>First, if there is a security manager, its <code>checkPermission</code>
* method is called with a <code>RuntimePermission("setIO")</code> permission
* to see if it's ok to reassign the "standard" error output stream.
*
* @param err the new standard error output stream.
*
* @throws SecurityException
* if a security manager exists and its
* <code>checkPermission</code> method doesn't allow
* reassigning of the standard error output stream.
*
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
*
* @since JDK1.1
*/
public static void setErr(PrintStream err) {
checkIO();
setErr0(err);
}
private static volatile Console cons = null;
Returns the unique Console
object associated with the current Java virtual machine, if any. Returns: The system console, if any, otherwise null. Since: 1.6
/**
* 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;
}
Returns the channel inherited from the entity that created this
Java virtual machine.
This method returns the channel obtained by invoking the
inheritedChannel
method of the system-wide default SelectorProvider
object.
In addition to the network-oriented channels described in
inheritedChannel
, this method may return other kinds of channels in the future.
Throws: - IOException –
If an I/O error occurs
- SecurityException –
If a security manager is present and it does not
permit access to the channel.
Returns: The inherited channel, if any, otherwise null. Since: 1.5
/**
* Returns the channel inherited from the entity that created this
* Java virtual machine.
*
* <p> This method returns the channel obtained by invoking the
* {@link java.nio.channels.spi.SelectorProvider#inheritedChannel
* inheritedChannel} method of the system-wide default
* {@link java.nio.channels.spi.SelectorProvider} object. </p>
*
* <p> In addition to the network-oriented channels described in
* {@link java.nio.channels.spi.SelectorProvider#inheritedChannel
* inheritedChannel}, this method may return other kinds of
* channels in the future.
*
* @return The inherited channel, if any, otherwise <tt>null</tt>.
*
* @throws IOException
* If an I/O error occurs
*
* @throws SecurityException
* If a security manager is present and it does not
* permit access to the channel.
*
* @since 1.5
*/
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);
Sets the System security.
If there is a security manager already installed, this method first
calls the security manager's checkPermission
method
with a RuntimePermission("setSecurityManager")
permission to ensure it's ok to replace the existing
security manager.
This may result in throwing a SecurityException
.
Otherwise, the argument is established as the current
security manager. If the argument is null
and no
security manager has been established, then no action is taken and
the method simply returns.
Params: - s – the security manager.
Throws: - SecurityException – if the security manager has already
been set and its
checkPermission
method
doesn't allow it to be replaced.
See Also:
/**
* Sets the System security.
*
* <p> If there is a security manager already installed, this method first
* calls the security manager's <code>checkPermission</code> method
* with a <code>RuntimePermission("setSecurityManager")</code>
* permission to ensure it's ok to replace the existing
* security manager.
* This may result in throwing a <code>SecurityException</code>.
*
* <p> Otherwise, the argument is established as the current
* security manager. If the argument is <code>null</code> and no
* security manager has been established, then no action is taken and
* the method simply returns.
*
* @param s the security manager.
* @exception SecurityException if the security manager has already
* been set and its <code>checkPermission</code> method
* doesn't allow it to be replaced.
* @see #getSecurityManager
* @see SecurityManager#checkPermission
* @see java.lang.RuntimePermission
*/
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.
See Also: Returns: if a security manager has already been established for the
current application, then that security manager is returned;
otherwise, null
is returned.
/**
* 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;
}
Returns the current time in milliseconds. Note that
while the unit of time of the return value is a millisecond,
the granularity of the value depends on the underlying
operating system and may be larger. For example, many
operating systems measure time in units of tens of
milliseconds.
See the description of the class Date
for
a discussion of slight discrepancies that may arise between
"computer time" and coordinated universal time (UTC).
See Also: Returns: the difference, measured in milliseconds, between
the current time and midnight, January 1, 1970 UTC.
/**
* Returns the current time in milliseconds. Note that
* while the unit of time of the return value is a millisecond,
* the granularity of the value depends on the underlying
* operating system and may be larger. For example, many
* operating systems measure time in units of tens of
* milliseconds.
*
* <p> See the description of the class <code>Date</code> for
* a discussion of slight discrepancies that may arise between
* "computer time" and coordinated universal time (UTC).
*
* @return the difference, measured in milliseconds, between
* the current time and midnight, January 1, 1970 UTC.
* @see java.util.Date
*/
public static native long currentTimeMillis();
Returns the current value of the running Java Virtual Machine's
high-resolution time source, in nanoseconds.
This method can only be used to measure elapsed time and is
not related to any other notion of system or wall-clock time.
The value returned represents nanoseconds since some fixed but
arbitrary origin time (perhaps in the future, so values
may be negative). The same origin is used by all invocations of
this method in an instance of a Java virtual machine; other
virtual machine instances are likely to use a different origin.
This method provides nanosecond precision, but not necessarily nanosecond resolution (that is, how frequently the value changes) - no guarantees are made except that the resolution is at least as good as that of currentTimeMillis()
.
Differences in successive calls that span greater than
approximately 292 years (263 nanoseconds) will not
correctly compute elapsed time due to numerical overflow.
The values returned by this method become meaningful only when
the difference between two such values, obtained within the same
instance of a Java virtual machine, is computed.
For example, to measure how long some code takes to execute:
long startTime = System.nanoTime();
// ... the code being measured ...
long estimatedTime = System.nanoTime() - startTime;
To compare two nanoTime values
long t0 = System.nanoTime();
...
long t1 = System.nanoTime();
one should use t1 - t0 < 0
, not t1 < t0
, because of the possibility of numerical overflow. Returns: the current value of the running Java Virtual Machine's
high-resolution time source, in nanoseconds Since: 1.5
/**
* Returns the current value of the running Java Virtual Machine's
* high-resolution time source, in nanoseconds.
*
* <p>This method can only be used to measure elapsed time and is
* not related to any other notion of system or wall-clock time.
* The value returned represents nanoseconds since some fixed but
* arbitrary <i>origin</i> time (perhaps in the future, so values
* may be negative). The same origin is used by all invocations of
* this method in an instance of a Java virtual machine; other
* virtual machine instances are likely to use a different origin.
*
* <p>This method provides nanosecond precision, but not necessarily
* nanosecond resolution (that is, how frequently the value changes)
* - no guarantees are made except that the resolution is at least as
* good as that of {@link #currentTimeMillis()}.
*
* <p>Differences in successive calls that span greater than
* approximately 292 years (2<sup>63</sup> nanoseconds) will not
* correctly compute elapsed time due to numerical overflow.
*
* <p>The values returned by this method become meaningful only when
* the difference between two such values, obtained within the same
* instance of a Java virtual machine, is computed.
*
* <p> For example, to measure how long some code takes to execute:
* <pre> {@code
* long startTime = System.nanoTime();
* // ... the code being measured ...
* long estimatedTime = System.nanoTime() - startTime;}</pre>
*
* <p>To compare two nanoTime values
* <pre> {@code
* long t0 = System.nanoTime();
* ...
* long t1 = System.nanoTime();}</pre>
*
* one should use {@code t1 - t0 < 0}, not {@code t1 < t0},
* because of the possibility of numerical overflow.
*
* @return the current value of the running Java Virtual Machine's
* high-resolution time source, in nanoseconds
* @since 1.5
*/
public static native long nanoTime();
Copies an array from the specified source array, beginning at the
specified position, to the specified position of the destination array.
A subsequence of array components are copied from the source
array referenced by src
to the destination array
referenced by dest
. The number of components copied is
equal to the length
argument. The components at
positions srcPos
through
srcPos+length-1
in the source array are copied into
positions destPos
through
destPos+length-1
, respectively, of the destination
array.
If the src
and dest
arguments refer to the
same array object, then the copying is performed as if the
components at positions srcPos
through
srcPos+length-1
were first copied to a temporary
array with length
components and then the contents of
the temporary array were copied into positions
destPos
through destPos+length-1
of the
destination array.
If dest
is null
, then a
NullPointerException
is thrown.
If src
is null
, then a
NullPointerException
is thrown and the destination
array is not modified.
Otherwise, if any of the following is true, an
ArrayStoreException
is thrown and the destination is
not modified:
- The
src
argument refers to an object that is not an
array.
- The
dest
argument refers to an object that is not an
array.
- The
src
argument and dest
argument refer
to arrays whose component types are different primitive types.
- The
src
argument refers to an array with a primitive
component type and the dest
argument refers to an array
with a reference component type.
- The
src
argument refers to an array with a reference
component type and the dest
argument refers to an array
with a primitive component type.
Otherwise, if any of the following is true, an
IndexOutOfBoundsException
is
thrown and the destination is not modified:
- The
srcPos
argument is negative.
- The
destPos
argument is negative.
- The
length
argument is negative.
srcPos+length
is greater than
src.length
, the length of the source array.
destPos+length
is greater than
dest.length
, the length of the destination array.
Otherwise, if any actual component of the source array from
position srcPos
through
srcPos+length-1
cannot be converted to the component
type of the destination array by assignment conversion, an
ArrayStoreException
is thrown. In this case, let
k be the smallest nonnegative integer less than
length such that src[srcPos+
k]
cannot be converted to the component type of the destination
array; when the exception is thrown, source array components from
positions srcPos
through
srcPos+
k-1
will already have been copied to destination array positions
destPos
through
destPos+
k-1
and no other
positions of the destination array will have been modified.
(Because of the restrictions already itemized, this
paragraph effectively applies only to the situation where both
arrays have component types that are reference types.)
Params: - src – the source array.
- srcPos – starting position in the source array.
- dest – the destination array.
- destPos – starting position in the destination data.
- length – the number of array elements to be copied.
Throws: - IndexOutOfBoundsException – if copying would cause
access of data outside array bounds.
- ArrayStoreException – if an element in the
src
array could not be stored into the dest
array
because of a type mismatch. - NullPointerException – if either
src
or
dest
is null
.
/**
* Copies an array from the specified source array, beginning at the
* specified position, to the specified position of the destination array.
* A subsequence of array components are copied from the source
* array referenced by <code>src</code> to the destination array
* referenced by <code>dest</code>. The number of components copied is
* equal to the <code>length</code> argument. The components at
* positions <code>srcPos</code> through
* <code>srcPos+length-1</code> in the source array are copied into
* positions <code>destPos</code> through
* <code>destPos+length-1</code>, respectively, of the destination
* array.
* <p>
* If the <code>src</code> and <code>dest</code> arguments refer to the
* same array object, then the copying is performed as if the
* components at positions <code>srcPos</code> through
* <code>srcPos+length-1</code> were first copied to a temporary
* array with <code>length</code> components and then the contents of
* the temporary array were copied into positions
* <code>destPos</code> through <code>destPos+length-1</code> of the
* destination array.
* <p>
* If <code>dest</code> is <code>null</code>, then a
* <code>NullPointerException</code> is thrown.
* <p>
* If <code>src</code> is <code>null</code>, then a
* <code>NullPointerException</code> is thrown and the destination
* array is not modified.
* <p>
* Otherwise, if any of the following is true, an
* <code>ArrayStoreException</code> is thrown and the destination is
* not modified:
* <ul>
* <li>The <code>src</code> argument refers to an object that is not an
* array.
* <li>The <code>dest</code> argument refers to an object that is not an
* array.
* <li>The <code>src</code> argument and <code>dest</code> argument refer
* to arrays whose component types are different primitive types.
* <li>The <code>src</code> argument refers to an array with a primitive
* component type and the <code>dest</code> argument refers to an array
* with a reference component type.
* <li>The <code>src</code> argument refers to an array with a reference
* component type and the <code>dest</code> argument refers to an array
* with a primitive component type.
* </ul>
* <p>
* Otherwise, if any of the following is true, an
* <code>IndexOutOfBoundsException</code> is
* thrown and the destination is not modified:
* <ul>
* <li>The <code>srcPos</code> argument is negative.
* <li>The <code>destPos</code> argument is negative.
* <li>The <code>length</code> argument is negative.
* <li><code>srcPos+length</code> is greater than
* <code>src.length</code>, the length of the source array.
* <li><code>destPos+length</code> is greater than
* <code>dest.length</code>, the length of the destination array.
* </ul>
* <p>
* Otherwise, if any actual component of the source array from
* position <code>srcPos</code> through
* <code>srcPos+length-1</code> cannot be converted to the component
* type of the destination array by assignment conversion, an
* <code>ArrayStoreException</code> is thrown. In this case, let
* <b><i>k</i></b> be the smallest nonnegative integer less than
* length such that <code>src[srcPos+</code><i>k</i><code>]</code>
* cannot be converted to the component type of the destination
* array; when the exception is thrown, source array components from
* positions <code>srcPos</code> through
* <code>srcPos+</code><i>k</i><code>-1</code>
* will already have been copied to destination array positions
* <code>destPos</code> through
* <code>destPos+</code><i>k</I><code>-1</code> and no other
* positions of the destination array will have been modified.
* (Because of the restrictions already itemized, this
* paragraph effectively applies only to the situation where both
* arrays have component types that are reference types.)
*
* @param src the source array.
* @param srcPos starting position in the source array.
* @param dest the destination array.
* @param destPos starting position in the destination data.
* @param length the number of array elements to be copied.
* @exception IndexOutOfBoundsException if copying would cause
* access of data outside array bounds.
* @exception ArrayStoreException if an element in the <code>src</code>
* array could not be stored into the <code>dest</code> array
* because of a type mismatch.
* @exception NullPointerException if either <code>src</code> or
* <code>dest</code> is <code>null</code>.
*/
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
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.
Params: - x – object for which the hashCode is to be calculated
Returns: the hashCode Since: JDK1.1
/**
* 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 properties. The following properties are guaranteed to be defined:
- java.version
- Java version number
- java.vendor
- Java vendor specific string
- java.vendor.url
- Java vendor URL
- java.home
- Java installation directory
- java.class.version
- Java class version number
- java.class.path
- Java classpath
- os.name
- Operating System Name
- os.arch
- Operating System Architecture
- os.version
- Operating System Version
- file.separator
- File separator ("/" on Unix)
- path.separator
- Path separator (":" on Unix)
- line.separator
- Line separator ("\n" on Unix)
- user.name
- User account name
- user.home
- User home directory
- user.dir
- User's current working directory
/**
* 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.
First, if there is a security manager, its
checkPropertiesAccess
method is called with no
arguments. This may result in a security exception.
The current set of system properties for use by the getProperty(String)
method is returned as a Properties
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:
Key
Description of Associated Value
java.version
Java Runtime Environment version
java.vendor
Java Runtime Environment vendor
java.vendor.url
Java vendor URL
java.home
Java installation directory
java.vm.specification.version
Java Virtual Machine specification version
java.vm.specification.vendor
Java Virtual Machine specification vendor
java.vm.specification.name
Java Virtual Machine specification name
java.vm.version
Java Virtual Machine implementation version
java.vm.vendor
Java Virtual Machine implementation vendor
java.vm.name
Java Virtual Machine implementation name
java.specification.version
Java Runtime Environment specification version
java.specification.vendor
Java Runtime Environment specification vendor
java.specification.name
Java Runtime Environment specification name
java.class.version
Java class format version number
java.class.path
Java class path
java.library.path
List of paths to search when loading libraries
java.io.tmpdir
Default temp file path
java.compiler
Name of JIT compiler to use
java.ext.dirs
Path of extension directory or directories
Deprecated. This property, and the mechanism
which implements it, may be removed in a future
release.
os.name
Operating system name
os.arch
Operating system architecture
os.version
Operating system version
file.separator
File separator ("/" on UNIX)
path.separator
Path separator (":" on UNIX)
line.separator
Line separator ("\n" on UNIX)
user.name
User's account name
user.home
User's home directory
user.dir
User's current working directory
Multiple paths in a system property value are separated by the path
separator character of the platform.
Note that even if the security manager does not permit the
getProperties
operation, it may choose to permit the getProperty(String)
operation.
Throws: - SecurityException – if a security manager exists and its
checkPropertiesAccess
method doesn't allow access
to the system properties.
See Also: Returns: the system properties
/**
* 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 system property line.separator
. On UNIX systems, it returns "\n"
; on Microsoft Windows systems it returns "\r\n"
.
Returns: the system-dependent line separator string Since: 1.7
/**
* 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 Properties
argument.
First, if there is a security manager, its
checkPropertiesAccess
method is called with no
arguments. This may result in a security exception.
The argument becomes the current set of system properties for use by the getProperty(String)
method. If the argument is null
, then the current set of system properties is
forgotten.
Params: - props – the new system properties.
Throws: - SecurityException – if a security manager exists and its
checkPropertiesAccess
method doesn't allow access
to the system properties.
See Also:
/**
* 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.
First, if there is a security manager, its
checkPropertyAccess
method is called with the key as
its argument. This may result in a SecurityException.
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 getProperties
method.
Params: - key – the name of the system property.
Throws: - SecurityException – if a security manager exists and its
checkPropertyAccess
method doesn't allow
access to the specified system property. - NullPointerException – if
key
is
null
. - IllegalArgumentException – if
key
is empty.
See Also: Returns: the string value of the system property,
or null
if there is no property with that 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 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.
First, if there is a security manager, its
checkPropertyAccess
method is called with the
key
as its argument.
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 getProperties
method.
Params: - key – the name of the system property.
- def – a default value.
Throws: - SecurityException – if a security manager exists and its
checkPropertyAccess
method doesn't allow
access to the specified system property. - NullPointerException – if
key
is
null
. - IllegalArgumentException – if
key
is empty.
See Also: Returns: the string value of the system property,
or the default value if there is no property with that 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.
First, if a security manager exists, its
SecurityManager.checkPermission
method
is called with a PropertyPermission(key, "write")
permission. This may result in a SecurityException being thrown.
If no exception is thrown, the specified property is set to the given
value.
Params: - key – the name of the system property.
- value – the value of the system property.
Throws: - SecurityException – if a security manager exists and its
checkPermission
method doesn't allow
setting of the specified property. - NullPointerException – if
key
or
value
is null
. - IllegalArgumentException – if
key
is empty.
See Also: Returns: the previous value of the system property,
or null
if it did not have one. Since: 1.2
/**
* 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.
First, if a security manager exists, its
SecurityManager.checkPermission
method
is called with a PropertyPermission(key, "write")
permission. This may result in a SecurityException being thrown.
If no exception is thrown, the specified property is removed.
Params: - key – the name of the system property to be removed.
Throws: - SecurityException – if a security manager exists and its
checkPropertyAccess
method doesn't allow
access to the specified system property. - NullPointerException – if
key
is
null
. - IllegalArgumentException – if
key
is empty.
See Also: Returns: the previous string value of the system property,
or null
if there was no property with that key. Since: 1.5
/**
* 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");
}
}
Gets the value of the specified environment variable. An
environment variable is a system-dependent external named
value.
If a security manager exists, its checkPermission
method is called with a RuntimePermission
("getenv."+name)
permission. This may result in a SecurityException
being thrown. If no exception is thrown the value of the variable name
is returned.
System
properties and environment variables 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 PATH
).
On UNIX systems the alphabetic case of name
is
typically significant, while on Microsoft Windows systems it is
typically not. For example, the expression
System.getenv("FOO").equals(System.getenv("foo"))
is likely to be true on Microsoft Windows.
Params: - name – the name of the environment variable
Throws: - NullPointerException – if
name
is null
- SecurityException – if a security manager exists and its
checkPermission
method doesn't allow access to the environment variable name
See Also: Returns: the string value of the variable, or null
if the variable is not defined in the system environment
/**
* 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.
If the system does not support environment variables, an
empty map is returned.
The returned map will never contain null keys or values. Attempting to query the presence of a null key or value will throw a NullPointerException
. Attempting to query the presence of a key or value which is not of type String
will throw a ClassCastException
.
The returned map and its collection views may not obey the general contract of the Object.equals
and Object.hashCode
methods.
The returned map is typically case-sensitive on all platforms.
If a security manager exists, its checkPermission
method is called with a RuntimePermission
("getenv.*")
permission. This may result in a SecurityException
being thrown.
When passing information to a Java subprocess,
system properties
are generally preferred over environment variables.
Throws: - SecurityException – if a security manager exists and its
checkPermission
method doesn't allow access to the process environment
See Also: Returns: the environment as a map of variable names to values Since: 1.5
/**
* 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();
}
Terminates the currently running Java Virtual Machine. The
argument serves as a status code; by convention, a nonzero status
code indicates abnormal termination.
This method calls the exit
method in class
Runtime
. This method never returns normally.
The call System.exit(n)
is effectively equivalent to
the call:
Runtime.getRuntime().exit(n)
Params: - status – exit status.
Throws: - SecurityException –
if a security manager exists and its
checkExit
method doesn't allow exit with the specified status.
See Also:
/**
* 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.
Calling the gc
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.
The call System.gc()
is effectively equivalent to the
call:
Runtime.getRuntime().gc()
See Also: - gc.gc()
/**
* 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.
Calling this method suggests that the Java Virtual Machine expend
effort toward running the finalize
methods of objects
that have been found to be discarded but whose finalize
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.
The call System.runFinalization()
is effectively
equivalent to the call:
Runtime.getRuntime().runFinalization()
See Also: - runFinalization.runFinalization()
/**
* 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.
If there is a security manager,
its checkExit
method is first called
with 0 as its argument to ensure the exit is allowed.
This could result in a SecurityException.
Params: - value – indicating enabling or disabling of finalization
Throws: - SecurityException –
if a security manager exists and its
checkExit
method doesn't allow the exit.
See Also: 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. Since: JDK1.1
/**
* 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);
}
Loads the native library specified by the filename argument. The filename
argument must be an absolute path name.
If the filename argument, when stripped of any platform-specific library
prefix, path, and file extension, indicates a library whose name is,
for example, L, and a native library called L is statically linked
with the VM, then the JNI_OnLoad_L function exported by the library
is invoked rather than attempting to load a dynamic library.
A filename matching the argument does not have to exist in the
file system.
See the JNI Specification for more details.
Otherwise, the filename argument is mapped to a native library image in
an implementation-dependent manner.
The call System.load(name)
is effectively equivalent
to the call:
Runtime.getRuntime().load(name)
Params: - filename – the file to load.
Throws: - SecurityException – if a security manager exists and its
checkLink
method doesn't allow
loading of the specified dynamic library - UnsatisfiedLinkError – if either the filename is not an
absolute path name, the native library is not statically
linked with the VM, or the library cannot be mapped to
a native library image by the host system.
- NullPointerException – if
filename
is
null
See Also:
/**
* Loads the native library specified by the filename argument. The filename
* argument must be an absolute path name.
*
* If the filename argument, when stripped of any platform-specific library
* prefix, path, and file extension, indicates a library whose name is,
* for example, L, and a native library called L is statically linked
* with the VM, then the JNI_OnLoad_L function exported by the library
* is invoked rather than attempting to load a dynamic library.
* A filename matching the argument does not have to exist in the
* file system.
* See the JNI Specification for more details.
*
* Otherwise, the filename argument is mapped to a native library image in
* an implementation-dependent manner.
*
* <p>
* The call <code>System.load(name)</code> is effectively equivalent
* to the call:
* <blockquote><pre>
* Runtime.getRuntime().load(name)
* </pre></blockquote>
*
* @param filename the file to load.
* @exception SecurityException if a security manager exists and its
* <code>checkLink</code> method doesn't allow
* loading of the specified dynamic library
* @exception UnsatisfiedLinkError if either the filename is not an
* absolute path name, the native library is not statically
* linked with the VM, or the library cannot be mapped to
* a native library image by the host system.
* @exception NullPointerException if <code>filename</code> is
* <code>null</code>
* @see java.lang.Runtime#load(java.lang.String)
* @see java.lang.SecurityManager#checkLink(java.lang.String)
*/
@CallerSensitive
public static void load(String filename) {
Runtime.getRuntime().load0(Reflection.getCallerClass(), filename);
}
Loads the native library specified by the libname
argument. The libname
argument must not contain any platform
specific prefix, file extension or path. If a native library
called libname
is statically linked with the VM, then the
JNI_OnLoad_libname
function exported by the library is invoked.
See the JNI Specification for more details.
Otherwise, the libname argument is loaded from a system library
location and mapped to a native library image in an implementation-
dependent manner.
The call System.loadLibrary(name)
is effectively
equivalent to the call
Runtime.getRuntime().loadLibrary(name)
Params: - libname – the name of the library.
Throws: - SecurityException – if a security manager exists and its
checkLink
method doesn't allow
loading of the specified dynamic library - UnsatisfiedLinkError – if either the libname argument
contains a file path, the native library is not statically
linked with the VM, or the library cannot be mapped to a
native library image by the host system.
- NullPointerException – if
libname
is
null
See Also:
/**
* Loads the native library specified by the <code>libname</code>
* argument. The <code>libname</code> argument must not contain any platform
* specific prefix, file extension or path. If a native library
* called <code>libname</code> is statically linked with the VM, then the
* JNI_OnLoad_<code>libname</code> function exported by the library is invoked.
* See the JNI Specification for more details.
*
* Otherwise, the libname argument is loaded from a system library
* location and mapped to a native library image in an implementation-
* dependent manner.
* <p>
* The call <code>System.loadLibrary(name)</code> is effectively
* equivalent to the call
* <blockquote><pre>
* Runtime.getRuntime().loadLibrary(name)
* </pre></blockquote>
*
* @param libname the name of the library.
* @exception SecurityException if a security manager exists and its
* <code>checkLink</code> method doesn't allow
* loading of the specified dynamic library
* @exception UnsatisfiedLinkError if either the libname argument
* contains a file path, the native library is not statically
* linked with the VM, or the library cannot be mapped to a
* native library image by the host system.
* @exception NullPointerException if <code>libname</code> is
* <code>null</code>
* @see java.lang.Runtime#loadLibrary(java.lang.String)
* @see java.lang.SecurityManager#checkLink(java.lang.String)
*/
@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.
Params: - libname – the name of the library.
Throws: - NullPointerException – if
libname
is
null
See Also: Returns: a platform-dependent native library name. Since: 1.2
/**
* 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);
Create PrintStream for stdout/err based on encoding.
/**
* 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.
/**
* 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");
StaticProperty.jdkSerialFilter(); // Load StaticProperty to cache the property values
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();
}
});
}
}