java(1) Basic Tools java(1)
NAME
java - Launches a Java application.
SYNOPSIS
java [options] classname [args]
java [options] -jar filename [args]
options
Command-line options separated by spaces. See Options.
classname
The name of the class to be launched.
filename
The name of the Java Archive (JAR) file to be called. Used only with the -jar option.
args
The arguments passed to the main() method separated by spaces.
DESCRIPTION
The java command starts a Java application. It does this by starting the Java Runtime Environment (JRE), loading the specified class, and calling that class's main() method. The method must be
declared public and static, it must not return any value, and it must accept a String array as a parameter. The method declaration has the following form:
public static void main(String[] args)
The java command can be used to launch a JavaFX application by loading a class that either has a main() method or that extends javafx.application.Application. In the latter case, the launcher
constructs an instance of the Application class, calls its init() method, and then calls the start(javafx.stage.Stage) method.
By default, the first argument that is not an option of the java command is the fully qualified name of the class to be called. If the -jar option is specified, its argument is the name of the JAR
file containing class and resource files for the application. The startup class must be indicated by the Main-Class manifest header in its source code.
The JRE searches for the startup class (and other classes used by the application) in three sets of locations: the bootstrap class path, the installed extensions, and the user’s class path.
Arguments after the class file name or the JAR file name are passed to the main() method.
OPTIONS
The java command supports a wide range of options that can be divided into the following categories:
· Standard Options
· Non-Standard Options
· Advanced Runtime Options
· Advanced JIT Compiler Options
· Advanced Serviceability Options
· Advanced Garbage Collection Options
Standard options are guaranteed to be supported by all implementations of the Java Virtual Machine (JVM). They are used for common actions, such as checking the version of the JRE, setting the class
path, enabling verbose output, and so on.
Non-standard options are general purpose options that are specific to the Java HotSpot Virtual Machine, so they are not guaranteed to be supported by all JVM implementations, and are subject to
change. These options start with -X.
Advanced options are not recommended for casual use. These are developer options used for tuning specific areas of the Java HotSpot Virtual Machine operation that often have specific system
requirements and may require privileged access to system configuration parameters. They are also not guaranteed to be supported by all JVM implementations, and are subject to change. Advanced
options start with -XX.
To keep track of the options that were deprecated or removed in the latest release, there is a section named Deprecated and Removed Options at the end of the document.
Boolean options are used to either enable a feature that is disabled by default or disable a feature that is enabled by default. Such options do not require a parameter. Boolean -XX options are
enabled using the plus sign (-XX:+OptionName) and disabled using the minus sign (-XX:-OptionName).
For options that require an argument, the argument may be separated from the option name by a space, a colon (:), or an equal sign (=), or the argument may directly follow the option (the exact
syntax differs for each option). If you are expected to specify the size in bytes, you can use no suffix, or use the suffix k or K for kilobytes (KB), m or M for megabytes (MB), g or G for gigabytes
(GB). For example, to set the size to 8 GB, you can specify either 8g, 8192m, 8388608k, or 8589934592 as the argument. If you are expected to specify the percentage, use a number from 0 to 1 (for
example, specify 0.25 for 25%).
Standard Options
These are the most commonly used options that are supported by all implementations of the JVM.
-agentlib:libname[=options]
Loads the specified native agent library. After the library name, a comma-separated list of options specific to the library can be used.
If the option -agentlib:foo is specified, then the JVM attempts to load the library named libfoo.so in the location specified by the LD_LIBRARY_PATH system variable (on OS X this variable is
DYLD_LIBRARY_PATH).
The following example shows how to load the heap profiling tool (HPROF) library and get sample CPU information every 20 ms, with a stack depth of 3:
-agentlib:hprof=cpu=samples,interval=20,depth=3
The following example shows how to load the Java Debug Wire Protocol (JDWP) library and listen for the socket connection on port 8000, suspending the JVM before the main class loads:
-agentlib:jdwp=transport=dt_socket,server=y,address=8000
For more information about the native agent libraries, refer to the following:
· The java.lang.instrument package description at http://docs.oracle.com/javase/8/docs/api/java/lang/instrument/package-summary.html
· Agent Command Line Options in the JVM Tools Interface guide at http://docs.oracle.com/javase/8/docs/platform/jvmti/jvmti.html#starting
-agentpath:pathname[=options]
Loads the native agent library specified by the absolute path name. This option is equivalent to -agentlib but uses the full path and file name of the library.
-client
Selects the Java HotSpot Client VM. The 64-bit version of the Java SE Development Kit (JDK) currently ignores this option and instead uses the Server JVM.
For default JVM selection, see Server-Class Machine Detection at http://docs.oracle.com/javase/8/docs/technotes/guides/vm/server-class.html
-Dproperty=value
Sets a system property value. The property variable is a string with no spaces that represents the name of the property. The value variable is a string that represents the value of the property.
If value is a string with spaces, then enclose it in quotation marks (for example -Dfoo="foo bar").
-d32
Runs the application in a 32-bit environment. If a 32-bit environment is not installed or is not supported, then an error will be reported. By default, the application is run in a 32-bit
environment unless a 64-bit system is used.
-d64
Runs the application in a 64-bit environment. If a 64-bit environment is not installed or is not supported, then an error will be reported. By default, the application is run in a 32-bit
environment unless a 64-bit system is used.
Currently only the Java HotSpot Server VM supports 64-bit operation, and the -server option is implicit with the use of -d64. The -client option is ignored with the use of -d64. This is subject
to change in a future release.
-disableassertions[:[packagename]...|:classname]
-da[:[packagename]...|:classname]
Disables assertions. By default, assertions are disabled in all packages and classes.
With no arguments, -disableassertions (-da) disables assertions in all packages and classes. With the packagename argument ending in ..., the switch disables assertions in the specified package
and any subpackages. If the argument is simply ..., then the switch disables assertions in the unnamed package in the current working directory. With the classname argument, the switch disables
assertions in the specified class.
The -disableassertions (-da) option applies to all class loaders and to system classes (which do not have a class loader). There is one exception to this rule: if the option is provided with no
arguments, then it does not apply to system classes. This makes it easy to disable assertions in all classes except for system classes. The -disablesystemassertions option enables you to disable
assertions in all system classes.
To explicitly enable assertions in specific packages or classes, use the -enableassertions (-ea) option. Both options can be used at the same time. For example, to run the MyClass application
with assertions enabled in package com.wombat.fruitbat (and any subpackages) but disabled in class com.wombat.fruitbat.Brickbat, use the following command:
java -ea:com.wombat.fruitbat... -da:com.wombat.fruitbat.Brickbat MyClass
-disablesystemassertions
-dsa
Disables assertions in all system classes.
-enableassertions[:[packagename]...|:classname]
-ea[:[packagename]...|:classname]
Enables assertions. By default, assertions are disabled in all packages and classes.
With no arguments, -enableassertions (-ea) enables assertions in all packages and classes. With the packagename argument ending in ..., the switch enables assertions in the specified package and
any subpackages. If the argument is simply ..., then the switch enables assertions in the unnamed package in the current working directory. With the classname argument, the switch enables
assertions in the specified class.
The -enableassertions (-ea) option applies to all class loaders and to system classes (which do not have a class loader). There is one exception to this rule: if the option is provided with no
arguments, then it does not apply to system classes. This makes it easy to enable assertions in all classes except for system classes. The -enablesystemassertions option provides a separate
switch to enable assertions in all system classes.
To explicitly disable assertions in specific packages or classes, use the -disableassertions (-da) option. If a single command contains multiple instances of these switches, then they are
processed in order before loading any classes. For example, to run the MyClass application with assertions enabled only in package com.wombat.fruitbat (and any subpackages) but disabled in class
com.wombat.fruitbat.Brickbat, use the following command:
java -ea:com.wombat.fruitbat... -da:com.wombat.fruitbat.Brickbat MyClass
-enablesystemassertions
-esa
Enables assertions in all system classes.
-help
-?
Displays usage information for the java command without actually running the JVM.
-jar filename
Executes a program encapsulated in a JAR file. The filename argument is the name of a JAR file with a manifest that contains a line in the form Main-Class:classname that defines the class with
the public static void main(String[] args) method that serves as your application's starting point.
When you use the -jar option, the specified JAR file is the source of all user classes, and other class path settings are ignored.
For more information about JAR files, see the following resources:
· jar(1)
· The Java Archive (JAR) Files guide at http://docs.oracle.com/javase/8/docs/technotes/guides/jar/index.html
· Lesson: Packaging Programs in JAR Files at
http://docs.oracle.com/javase/tutorial/deployment/jar/index.html
-javaagent:jarpath[=options]
Loads the specified Java programming language agent. For more information about instrumenting Java applications, see the java.lang.instrument package description in the Java API documentation at
http://docs.oracle.com/javase/8/docs/api/java/lang/instrument/package-summary.html
-jre-restrict-search
Includes user-private JREs in the version search.
-no-jre-restrict-search
Excludes user-private JREs from the version search.
-server
Selects the Java HotSpot Server VM. The 64-bit version of the JDK supports only the Server VM, so in that case the option is implicit.
For default JVM selection, see Server-Class Machine Detection at http://docs.oracle.com/javase/8/docs/technotes/guides/vm/server-class.html
-showversion
Displays version information and continues execution of the application. This option is equivalent to the -version option except that the latter instructs the JVM to exit after displaying
version information.
-splash:imgname
Shows the splash screen with the image specified by imgname. For example, to show the splash.gif file from the images directory when starting your application, use the following option:
-splash:images/splash.gif
-verbose:class
Displays information about each loaded class.
-verbose:gc
Displays information about each garbage collection (GC) event.
-verbose:jni
Displays information about the use of native methods and other Java Native Interface (JNI) activity.
-version
Displays version information and then exits. This option is equivalent to the -showversion option except that the latter does not instruct the JVM to exit after displaying version information.
-version:release
Specifies the release version to be used for running the application. If the version of the java command called does not meet this specification and an appropriate implementation is found on the
system, then the appropriate implementation will be used.
The release argument specifies either the exact version string, or a list of version strings and ranges separated by spaces. A version string is the developer designation of the version number
in the following form: 1.x.0_u (where x is the major version number, and u is the update version number). A version range is made up of a version string followed by a plus sign (+) to designate
this version or later, or a part of a version string followed by an asterisk (*) to designate any version string with a matching prefix. Version strings and ranges can be combined using a space
for a logical OR combination, or an ampersand (&) for a logical AND combination of two version strings/ranges. For example, if running the class or JAR file requires either JRE 6u13 (1.6.0_13),
or any JRE 6 starting from 6u10 (1.6.0_10), specify the following:
-version:"1.6.0_13 1.6* & 1.6.0_10+"
Quotation marks are necessary only if there are spaces in the release parameter.
For JAR files, the preference is to specify version requirements in the JAR file manifest rather than on the command line.
Non-Standard Options
These options are general purpose options that are specific to the Java HotSpot Virtual Machine.
-X
Displays help for all available -X options.
-Xbatch
Disables background compilation. By default, the JVM compiles the method as a background task, running the method in interpreter mode until the background compilation is finished. The -Xbatch
flag disables background compilation so that compilation of all methods proceeds as a foreground task until completed.
This option is equivalent to -XX:-BackgroundCompilation.
-Xbootclasspath:path
Specifies a list of directories, JAR files, and ZIP archives separated by colons (:) to search for boot class files. These are used in place of the boot class files included in the JDK.
Do not deploy applications that use this option to override a class in rt.jar, because this violates the JRE binary code license.
-Xbootclasspath/a:path
Specifies a list of directories, JAR files, and ZIP archives separated by colons (:) to append to the end of the default bootstrap class path.
Do not deploy applications that use this option to override a class in rt.jar, because this violates the JRE binary code license.
-Xbootclasspath/p:path
Specifies a list of directories, JAR files, and ZIP archives separated by colons (:) to prepend to the front of the default bootstrap class path.
Do not deploy applications that use this option to override a class in rt.jar, because this violates the JRE binary code license.
-Xcheck:jni
Performs additional checks for Java Native Interface (JNI) functions. Specifically, it validates the parameters passed to the JNI function and the runtime environment data before processing the
JNI request. Any invalid data encountered indicates a problem in the native code, and the JVM will terminate with an irrecoverable error in such cases. Expect a performance degradation when this
option is used.
-Xcomp
Forces compilation of methods on first invocation. By default, the Client VM (-client) performs 1,000 interpreted method invocations and the Server VM (-server) performs 10,000 interpreted
method invocations to gather information for efficient compilation. Specifying the -Xcomp option disables interpreted method invocations to increase compilation performance at the expense of
efficiency.
You can also change the number of interpreted method invocations before compilation using the -XX:CompileThreshold option.
-Xdebug
Does nothing. Provided for backward compatibility.
-Xdiag
Shows additional diagnostic messages.
-Xfuture
Enables strict class-file format checks that enforce close conformance to the class-file format specification. Developers are encouraged to use this flag when developing new code because the
stricter checks will become the default in future releases.
-Xint
Runs the application in interpreted-only mode. Compilation to native code is disabled, and all bytecode is executed by the interpreter. The performance benefits offered by the just in time (JIT)
compiler are not present in this mode.
-Xinternalversion
Displays more detailed JVM version information than the -version option, and then exits.
-Xloggc:filename
Sets the file to which verbose GC events information should be redirected for logging. The information written to this file is similar to the output of -verbose:gc with the time elapsed since
the first GC event preceding each logged event. The -Xloggc option overrides -verbose:gc if both are given with the same java command.
Example:
-Xloggc:garbage-collection.log
-Xmaxjitcodesize=size
Specifies the maximum code cache size (in bytes) for JIT-compiled code. Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to indicate gigabytes. The default
maximum code cache size is 240 MB; if you disable tiered compilation with the option -XX:-TieredCompilation, then the default size is 48 MB:
-Xmaxjitcodesize=240m
This option is equivalent to -XX:ReservedCodeCacheSize.
-Xmixed
Executes all bytecode by the interpreter except for hot methods, which are compiled to native code.
-Xmnsize
Sets the initial and maximum size (in bytes) of the heap for the young generation (nursery). Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to indicate
gigabytes.
The young generation region of the heap is used for new objects. GC is performed in this region more often than in other regions. If the size for the young generation is too small, then a lot of
minor garbage collections will be performed. If the size is too large, then only full garbage collections will be performed, which can take a long time to complete. Oracle recommends that you
keep the size for the young generation between a half and a quarter of the overall heap size.
The following examples show how to set the initial and maximum size of young generation to 256 MB using various units:
-Xmn256m
-Xmn262144k
-Xmn268435456
Instead of the -Xmn option to set both the initial and maximum size of the heap for the young generation, you can use -XX:NewSize to set the initial size and -XX:MaxNewSize to set the maximum
size.
-Xmssize
Sets the initial size (in bytes) of the heap. This value must be a multiple of 1024 and greater than 1 MB. Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to
indicate gigabytes.
The following examples show how to set the size of allocated memory to 6 MB using various units:
-Xms6291456
-Xms6144k
-Xms6m
If you do not set this option, then the initial size will be set as the sum of the sizes allocated for the old generation and the young generation. The initial size of the heap for the young
generation can be set using the -Xmn option or the -XX:NewSize option.
-Xmxsize
Specifies the maximum size (in bytes) of the memory allocation pool in bytes. This value must be a multiple of 1024 and greater than 2 MB. Append the letter k or K to indicate kilobytes, m or M
to indicate megabytes, g or G to indicate gigabytes. The default value is chosen at runtime based on system configuration. For server deployments, -Xms and -Xmx are often set to the same value.
See the section "Ergonomics" in Java SE HotSpot Virtual Machine Garbage Collection Tuning Guide at http://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/index.html.
The following examples show how to set the maximum allowed size of allocated memory to 80 MB using various units:
-Xmx83886080
-Xmx81920k
-Xmx80m
The -Xmx option is equivalent to -XX:MaxHeapSize.
-Xnoclassgc
Disables garbage collection (GC) of classes. This can save some GC time, which shortens interruptions during the application run.
When you specify -Xnoclassgc at startup, the class objects in the application will be left untouched during GC and will always be considered live. This can result in more memory being
permanently occupied which, if not used carefully, will throw an out of memory exception.
-Xprof
Profiles the running program and sends profiling data to standard output. This option is provided as a utility that is useful in program development and is not intended to be used in production
systems.
-Xrs
Reduces the use of operating system signals by the JVM.
Shutdown hooks enable orderly shutdown of a Java application by running user cleanup code (such as closing database connections) at shutdown, even if the JVM terminates abruptly.
The JVM catches signals to implement shutdown hooks for unexpected termination. The JVM uses SIGHUP, SIGINT, and SIGTERM to initiate the running of shutdown hooks.
The JVM uses a similar mechanism to implement the feature of dumping thread stacks for debugging purposes. The JVM uses SIGQUIT to perform thread dumps.
Applications embedding the JVM frequently need to trap signals such as SIGINT or SIGTERM, which can lead to interference with the JVM signal handlers. The -Xrs option is available to address
this issue. When -Xrs is used, the signal masks for SIGINT, SIGTERM, SIGHUP, and SIGQUIT are not changed by the JVM, and signal handlers for these signals are not installed.
There are two consequences of specifying -Xrs:
· SIGQUIT thread dumps are not available.
· User code is responsible for causing shutdown hooks to run, for example, by calling System.exit() when the JVM is to be terminated.
-Xshare:mode
Sets the class data sharing (CDS) mode. Possible mode arguments for this option include the following:
auto
Use CDS if possible. This is the default value for Java HotSpot 32-Bit Client VM.
on
Require the use of CDS. Print an error message and exit if class data sharing cannot be used.
off
Do not use CDS. This is the default value for Java HotSpot 32-Bit Server VM, Java HotSpot 64-Bit Client VM, and Java HotSpot 64-Bit Server VM.
dump
Manually generate the CDS archive. Specify the application class path as described in "Setting the Class Path ".
You should regenerate the CDS archive with each new JDK release.
-XshowSettings:category
Shows settings and continues. Possible category arguments for this option include the following:
all
Shows all categories of settings. This is the default value.
locale
Shows settings related to locale.
properties
Shows settings related to system properties.
vm
Shows the settings of the JVM.
-Xsssize
Sets the thread stack size (in bytes). Append the letter k or K to indicate KB, m or M to indicate MB, g or G to indicate GB. The default value depends on the platform:
· Linux/ARM (32-bit): 320 KB
· Linux/i386 (32-bit): 320 KB
· Linux/x64 (64-bit): 1024 KB
· OS X (64-bit): 1024 KB
· Oracle Solaris/i386 (32-bit): 320 KB
· Oracle Solaris/x64 (64-bit): 1024 KB
The following examples set the thread stack size to 1024 KB in different units:
-Xss1m
-Xss1024k
-Xss1048576
This option is equivalent to -XX:ThreadStackSize.
-Xusealtsigs
Use alternative signals instead of SIGUSR1 and SIGUSR2 for JVM internal signals. This option is equivalent to -XX:+UseAltSigs.
-Xverify:mode
Sets the mode of the bytecode verifier. Bytecode verification ensures that class files are properly formed and satisfy the constraints listed in section 4.10, "Verification of class Files" in
the The Java Virtual Machine Specification:
https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.10
Do not turn off verification as this reduces the protection provided by Java and could cause problems due to ill-formed class files.
Possible mode arguments for this option include the following:
remote
Verifies all bytecodes not loaded by the bootstrap class loader. This is the default behavior if you do not specify the -Xverify option.
all
Enables verification of all bytecodes.
none
Disables verification of all bytecodes. Use of -Xverify:none is unsupported.
Advanced Runtime Options
These options control the runtime behavior of the Java HotSpot VM.
-XX:+CheckEndorsedAndExtDirs
Enables the option to prevent the java command from running a Java application if it uses the endorsed-standards override mechanism or the extension mechanism. This option checks if an
application is using one of these mechanisms by checking the following:
· The java.ext.dirs or java.endorsed.dirs system property is set.
· The lib/endorsed directory exists and is not empty.
· The lib/ext directory contains any JAR files other than those of the JDK.
· The system-wide platform-specific extension directory contains any JAR files.
-XX:+DisableAttachMechanism
Enables the option that disables the mechanism that lets tools attach to the JVM. By default, this option is disabled, meaning that the attach mechanism is enabled and you can use tools such as
jcmd, jstack, jmap, and jinfo.
-XX:ErrorFile=filename
Specifies the path and file name to which error data is written when an irrecoverable error occurs. By default, this file is created in the current working directory and named hs_err_pidpid.log
where pid is the identifier of the process that caused the error. The following example shows how to set the default log file (note that the identifier of the process is specified as %p):
-XX:ErrorFile=./hs_err_pid%p.log
The following example shows how to set the error log to /var/log/java/java_error.log:
-XX:ErrorFile=/var/log/java/java_error.log
If the file cannot be created in the specified directory (due to insufficient space, permission problem, or another issue), then the file is created in the temporary directory for the operating
system. The temporary directory is /tmp.
-XX:+FailOverToOldVerifier
Enables automatic failover to the old verifier when the new type checker fails. By default, this option is disabled and it is ignored (that is, treated as disabled) for classes with a recent
bytecode version. You can enable it for classes with older versions of the bytecode.
-XX:+FlightRecorder
Enables the use of the Java Flight Recorder (JFR) during the runtime of the application. This is a commercial feature that works in conjunction with the -XX:+UnlockCommercialFeatures option as
follows:
java -XX:+UnlockCommercialFeatures -XX:+FlightRecorder
If this option is not provided, Java Flight Recorder can still be enabled in a running JVM by providing the appropriate jcmd diagnostic commands.
-XX:-FlightRecorder
Disables the use of the Java Flight Recorder (JFR) during the runtime of the application. This is a commercial feature that works in conjunction with the -XX:+UnlockCommercialFeatures option as
follows:
java -XX:+UnlockCommercialFeatures -XX:-FlightRecorder
If this option is provided, Java Flight Recorder cannot be enabled in a running JVM.
-XX:FlightRecorderOptions=parameter=value
Sets the parameters that control the behavior of JFR. This is a commercial feature that works in conjunction with the -XX:+UnlockCommercialFeatures option. This option can be used only when JFR
is enabled (that is, the -XX:+FlightRecorder option is specified).
The following list contains all available JFR parameters:
defaultrecording={true|false}
Specifies whether the recording is a continuous background recording or if it runs for a limited time. By default, this parameter is set to false (recording runs for a limited time). To make
the recording run continuously, set the parameter to true.
disk={true|false}
Specifies whether JFR should write a continuous recording to disk. By default, this parameter is set to false (continuous recording to disk is disabled). To enable it, set the parameter to
true, and also set defaultrecording=true.
dumponexit={true|false}
Specifies whether a dump file of JFR data should be generated when the JVM terminates in a controlled manner. By default, this parameter is set to false (dump file on exit is not generated).
To enable it, set the parameter to true, and also set defaultrecording=true.
The dump file is written to the location defined by the dumponexitpath parameter.
dumponexitpath=path
Specifies the path and name of the dump file with JFR data that is created when the JVM exits in a controlled manner if you set the dumponexit=true parameter. Setting the path makes sense
only if you also set defaultrecording=true.
If the specified path is a directory, the JVM assigns a file name that shows the creation date and time. If the specified path includes a file name and if that file already exists, the JVM
creates a new file by appending the date and time stamp to the specified file name.
globalbuffersize=size
Specifies the total amount of primary memory (in bytes) used for data retention. Append k or K, to specify the size in KB, m or M to specify the size in MB, g or G to specify the size in GB.
By default, the size is set to 462848 bytes.
loglevel={quiet|error|warning|info|debug|trace}
Specify the amount of data written to the log file by JFR. By default, it is set to info.
maxage=time
Specifies the maximum age of disk data to keep for the default recording. Append s to specify the time in seconds, m for minutes, h for hours, or d for days (for example, specifying 30s
means 30 seconds). By default, the maximum age is set to 15 minutes (15m).
This parameter is valid only if you set the disk=true parameter.
maxchunksize=size
Specifies the maximum size (in bytes) of the data chunks in a recording. Append k or K, to specify the size in KB, m or M to specify the size in MB, g or G to specify the size in GB. By
default, the maximum size of data chunks is set to 12 MB.
maxsize=size
Specifies the maximum size (in bytes) of disk data to keep for the default recording. Append k or K, to specify the size in KB, m or M to specify the size in MB, g or G to specify the size
in GB. By default, the maximum size of disk data is not limited, and this parameter is set to 0.
This parameter is valid only if you set the disk=true parameter.
repository=path
Specifies the repository (a directory) for temporary disk storage. By default, the system’s temporary directory is used.
samplethreads={true|false}
Specifies whether thread sampling is enabled. Thread sampling occurs only if the sampling event is enabled along with this parameter. By default, this parameter is enabled.
settings=path
Specifies the path and name of the event settings file (of type JFC). By default, the default.jfc file is used, which is located in JAVA_HOME/jre/lib/jfr.
stackdepth=depth
Stack depth for stack traces by JFR. By default, the depth is set to 64 method calls. The maximum is 2048, minimum is 1.
threadbuffersize=size
Specifies the per-thread local buffer size (in bytes). Append k or K, to specify the size in KB, m or M to specify the size in MB, g or G to specify the size in GB. Higher values for this
parameter allow more data gathering without contention to flush it to the global storage. It can increase application footprint in a thread-rich environment. By default, the local buffer
size is set to 5 KB.
You can specify values for multiple parameters by separating them with a comma. For example, to instruct JFR to write a continuous recording to disk, and set the maximum size of data chunks to
10 MB, specify the following:
-XX:FlightRecorderOptions=defaultrecording=true,disk=true,maxchunksize=10M
-XX:LargePageSizeInBytes=size
On Solaris, sets the maximum size (in bytes) for large pages used for Java heap. The size argument must be a power of 2 (2, 4, 8, 16, ...). Append the letter k or K to indicate kilobytes, m or M
to indicate megabytes, g or G to indicate gigabytes. By default, the size is set to 0, meaning that the JVM chooses the size for large pages automatically.
The following example illustrates how to set the large page size to 4 megabytes (MB):
-XX:LargePageSizeInBytes=4m
-XX:MaxDirectMemorySize=size
Sets the maximum total size (in bytes) of the New I/O (the java.nio package) direct-buffer allocations. Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to
indicate gigabytes. By default, the size is set to 0, meaning that the JVM chooses the size for NIO direct-buffer allocations automatically.
The following examples illustrate how to set the NIO size to 1024 KB in different units:
-XX:MaxDirectMemorySize=1m
-XX:MaxDirectMemorySize=1024k
-XX:MaxDirectMemorySize=1048576
-XX:NativeMemoryTracking=mode
Specifies the mode for tracking JVM native memory usage. Possible mode arguments for this option include the following:
off
Do not track JVM native memory usage. This is the default behavior if you do not specify the -XX:NativeMemoryTracking option.
summary
Only track memory usage by JVM subsystems, such as Java heap, class, code, and thread.
detail
In addition to tracking memory usage by JVM subsystems, track memory usage by individual CallSite, individual virtual memory region and its committed regions.
-XX:ObjectAlignmentInBytes=alignment
Sets the memory alignment of Java objects (in bytes). By default, the value is set to 8 bytes. The specified value should be a power of two, and must be within the range of 8 and 256
(inclusive). This option makes it possible to use compressed pointers with large Java heap sizes.
The heap size limit in bytes is calculated as:
4GB * ObjectAlignmentInBytes
Note: As the alignment value increases, the unused space between objects will also increase. As a result, you may not realize any benefits from using compressed pointers with large Java heap
sizes.
-XX:OnError=string
Sets a custom command or a series of semicolon-separated commands to run when an irrecoverable error occurs. If the string contains spaces, then it must be enclosed in quotation marks.
The following example shows how the -XX:OnError option can be used to run the gcore command to create the core image, and the debugger is started to attach to the process in case of an
irrecoverable error (the %p designates the current process):
-XX:OnError="gcore %p;dbx - %p"
-XX:OnOutOfMemoryError=string
Sets a custom command or a series of semicolon-separated commands to run when an OutOfMemoryError exception is first thrown. If the string contains spaces, then it must be enclosed in quotation
marks. For an example of a command string, see the description of the -XX:OnError option.
-XX:+PerfDataSaveToFile
If enabled, saves jstat(1) binary data when the Java application exits. This binary data is saved in a file named hsperfdata_<pid>, where <pid> is the process identifier of the Java application
you ran. Use jstat to display the performance data contained in this file as follows:
jstat -class file:///<path>/hsperfdata_<pid>
jstat -gc file:///<path>/hsperfdata_<pid>
-XX:+PrintCommandLineFlags
Enables printing of ergonomically selected JVM flags that appeared on the command line. It can be useful to know the ergonomic values set by the JVM, such as the heap space size and the selected
garbage collector. By default, this option is disabled and flags are not printed.
-XX:+PrintNMTStatistics
Enables printing of collected native memory tracking data at JVM exit when native memory tracking is enabled (see -XX:NativeMemoryTracking). By default, this option is disabled and native memory
tracking data is not printed.
-XX:+RelaxAccessControlCheck
Decreases the amount of access control checks in the verifier. By default, this option is disabled, and it is ignored (that is, treated as disabled) for classes with a recent bytecode version.
You can enable it for classes with older versions of the bytecode.
-XX:+ResourceManagement
Enables the use of Resource Management during the runtime of the application.
This is a commercial feature that requires you to also specify the -XX:+UnlockCommercialFeatures option as follows:
java -XX:+UnlockCommercialFeatures -XX:+ResourceManagement
-XX:ResourceManagementSampleInterval=value (milliseconds)
Sets the parameter that controls the sampling interval for Resource Management measurements, in milliseconds.
This option can be used only when Resource Management is enabled (that is, the -XX:+ResourceManagement option is specified).
-XX:SharedArchiveFile=path
Specifies the path and name of the class data sharing (CDS) archive file
-XX:SharedClassListFile=file_name
Specifies the text file that contains the names of the class files to store in the class data sharing (CDS) archive. This file contains the full name of one class file per line, except slashes
(/) replace dots (.). For example, to specify the classes java.lang.Object and hello.Main, create a text file that contains the following two lines:
java/lang/Object
hello/Main
The class files that you specify in this text file should include the classes that are commonly used by the application. They may include any classes from the application, extension, or
bootstrap class paths.
-XX:+ShowMessageBoxOnError
Enables displaying of a dialog box when the JVM experiences an irrecoverable error. This prevents the JVM from exiting and keeps the process active so that you can attach a debugger to it to
investigate the cause of the error. By default, this option is disabled.
-XX:StartFlightRecording=parameter=value
Starts a JFR recording for the Java application. This is a commercial feature that works in conjunction with the -XX:+UnlockCommercialFeatures option. This option is equivalent to the JFR.start
diagnostic command that starts a recording during runtime. You can set the following parameters when starting a JFR recording:
compress={true|false}
Specifies whether to compress the JFR recording log file (of type JFR) on the disk using the gzip file compression utility. This parameter is valid only if the filename parameter is
specified. By default it is set to false (recording is not compressed). To enable compression, set the parameter to true.
defaultrecording={true|false}
Specifies whether the recording is a continuous background recording or if it runs for a limited time. By default, this parameter is set to false (recording runs for a limited time). To make
the recording run continuously, set the parameter to true.
delay=time
Specifies the delay between the Java application launch time and the start of the recording. Append s to specify the time in seconds, m for minutes, h for hours, or d for days (for example,
specifying 10m means 10 minutes). By default, there is no delay, and this parameter is set to 0.
dumponexit={true|false}
Specifies whether a dump file of JFR data should be generated when the JVM terminates in a controlled manner. By default, this parameter is set to false (dump file on exit is not generated).
To enable it, set the parameter to true.
The dump file is written to the location defined by the filename parameter.
Example:
-XX:StartFlightRecording=name=test,filename=D:\test.jfr,dumponexit=true
duration=time
Specifies the duration of the recording. Append s to specify the time in seconds, m for minutes, h for hours, or d for days (for example, specifying 5h means 5 hours). By default, the
duration is not limited, and this parameter is set to 0.
filename=path
Specifies the path and name of the JFR recording log file.
name=identifier
Specifies the identifier for the JFR recording. By default, it is set to Recording x.
maxage=time
Specifies the maximum age of disk data to keep for the default recording. Append s to specify the time in seconds, m for minutes, h for hours, or d for days (for example, specifying 30s
means 30 seconds). By default, the maximum age is set to 15 minutes (15m).
maxsize=size
Specifies the maximum size (in bytes) of disk data to keep for the default recording. Append k or K, to specify the size in KB, m or M to specify the size in MB, g or G to specify the size
in GB. By default, the maximum size of disk data is not limited, and this parameter is set to 0.
settings=path
Specifies the path and name of the event settings file (of type JFC). By default, the default.jfc file is used, which is located in JAVA_HOME/jre/lib/jfr.
You can specify values for multiple parameters by separating them with a comma. For example, to save the recording to test.jfr in the current working directory, and instruct JFR to compress the
log file, specify the following:
-XX:StartFlightRecording=filename=test.jfr,compress=true
-XX:ThreadStackSize=size
Sets the thread stack size (in bytes). Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to indicate gigabytes. The default value depends on the platform:
· Linux/ARM (32-bit): 320 KB
· Linux/i386 (32-bit): 320 KB
· Linux/x64 (64-bit): 1024 KB
· OS X (64-bit): 1024 KB
· Oracle Solaris/i386 (32-bit): 320 KB
· Oracle Solaris/x64 (64-bit): 1024 KB
The following examples show how to set the thread stack size to 1024 KB in different units:
-XX:ThreadStackSize=1m
-XX:ThreadStackSize=1024k
-XX:ThreadStackSize=1048576
This option is equivalent to -Xss.
-XX:+TraceClassLoading
Enables tracing of classes as they are loaded. By default, this option is disabled and classes are not traced.
-XX:+TraceClassLoadingPreorder
Enables tracing of all loaded classes in the order in which they are referenced. By default, this option is disabled and classes are not traced.
-XX:+TraceClassResolution
Enables tracing of constant pool resolutions. By default, this option is disabled and constant pool resolutions are not traced.
-XX:+TraceClassUnloading
Enables tracing of classes as they are unloaded. By default, this option is disabled and classes are not traced.
-XX:+TraceLoaderConstraints
Enables tracing of the loader constraints recording. By default, this option is disabled and loader constraints recording is not traced.
-XX:+UnlockCommercialFeatures
Enables the use of commercial features. Commercial features are included with Oracle Java SE Advanced or Oracle Java SE Suite packages, as defined on the Java SE Products page at
http://www.oracle.com/technetwork/java/javase/terms/products/index.html
By default, this option is disabled and the JVM runs without the commercial features. Once they were enabled for a JVM process, it is not possible to disable their use for that process.
If this option is not provided, commercial features can still be unlocked in a running JVM by using the appropriate jcmd diagnostic commands.
-XX:+UseAltSigs
Enables the use of alternative signals instead of SIGUSR1 and SIGUSR2 for JVM internal signals. By default, this option is disabled and alternative signals are not used. This option is
equivalent to -Xusealtsigs.
-XX:+UseAppCDS
Enables application class data sharing (AppCDS). To use AppCDS, you must also specify values for the options -XX:SharedClassListFile and -XX:SharedArchiveFile during both CDS dump time (see the
option -Xshare:dump) and application run time.
This is a commercial feature that requires you to also specify the -XX:+UnlockCommercialFeatures option. This is also an experimental feature; it may change in future releases.
See "Application Class Data Sharing".
-XX:-UseBiasedLocking
Disables the use of biased locking. Some applications with significant amounts of uncontended synchronization may attain significant speedups with this flag enabled, whereas applications with
certain patterns of locking may see slowdowns. For more information about the biased locking technique, see the example in Java Tuning White Paper at
http://www.oracle.com/technetwork/java/tuning-139912.html#section4.2.5
By default, this option is enabled.
-XX:-UseCompressedOops
Disables the use of compressed pointers. By default, this option is enabled, and compressed pointers are used when Java heap sizes are less than 32 GB. When this option is enabled, object
references are represented as 32-bit offsets instead of 64-bit pointers, which typically increases performance when running the application with Java heap sizes less than 32 GB. This option
works only for 64-bit JVMs.
It is also possible to use compressed pointers when Java heap sizes are greater than 32GB. See the -XX:ObjectAlignmentInBytes option.
-XX:+UseHugeTLBFS
This option for Linux is the equivalent of specifying -XX:+UseLargePages. This option is disabled by default. This option pre-allocates all large pages up-front, when memory is reserved;
consequently the JVM cannot dynamically grow or shrink large pages memory areas; see -XX:UseTransparentHugePages if you want this behavior.
For more information, see "Large Pages".
-XX:+UseLargePages
Enables the use of large page memory. By default, this option is disabled and large page memory is not used.
For more information, see "Large Pages".
-XX:+UseMembar
Enables issuing of membars on thread state transitions. This option is disabled by default on all platforms except ARM servers, where it is enabled. (It is recommended that you do not disable
this option on ARM servers.)
-XX:+UsePerfData
Enables the perfdata feature. This option is enabled by default to allow JVM monitoring and performance testing. Disabling it suppresses the creation of the hsperfdata_userid directories. To
disable the perfdata feature, specify -XX:-UsePerfData.
-XX:+UseTransparentHugePages
On Linux, enables the use of large pages that can dynamically grow or shrink. This option is disabled by default. You may encounter performance problems with transparent huge pages as the OS
moves other pages around to create huge pages; this option is made available for experimentation.
For more information, see "Large Pages".
-XX:+AllowUserSignalHandlers
Enables installation of signal handlers by the application. By default, this option is disabled and the application is not allowed to install signal handlers.
Advanced JIT Compiler Options
These options control the dynamic just-in-time (JIT) compilation performed by the Java HotSpot VM.
-XX:+AggressiveOpts
Enables the use of aggressive performance optimization features, which are expected to become default in upcoming releases. By default, this option is disabled and experimental performance
features are not used.
-XX:AllocateInstancePrefetchLines=lines
Sets the number of lines to prefetch ahead of the instance allocation pointer. By default, the number of lines to prefetch is set to 1:
-XX:AllocateInstancePrefetchLines=1
Only the Java HotSpot Server VM supports this option.
-XX:AllocatePrefetchDistance=size
Sets the size (in bytes) of the prefetch distance for object allocation. Memory about to be written with the value of new objects is prefetched up to this distance starting from the address of
the last allocated object. Each Java thread has its own allocation point.
Negative values denote that prefetch distance is chosen based on the platform. Positive values are bytes to prefetch. Append the letter k or K to indicate kilobytes, m or M to indicate
megabytes, g or G to indicate gigabytes. The default value is set to -1.
The following example shows how to set the prefetch distance to 1024 bytes:
-XX:AllocatePrefetchDistance=1024
Only the Java HotSpot Server VM supports this option.
-XX:AllocatePrefetchInstr=instruction
Sets the prefetch instruction to prefetch ahead of the allocation pointer. Only the Java HotSpot Server VM supports this option. Possible values are from 0 to 3. The actual instructions behind
the values depend on the platform. By default, the prefetch instruction is set to 0:
-XX:AllocatePrefetchInstr=0
Only the Java HotSpot Server VM supports this option.
-XX:AllocatePrefetchLines=lines
Sets the number of cache lines to load after the last object allocation by using the prefetch instructions generated in compiled code. The default value is 1 if the last allocated object was an
instance, and 3 if it was an array.
The following example shows how to set the number of loaded cache lines to 5:
-XX:AllocatePrefetchLines=5
Only the Java HotSpot Server VM supports this option.
-XX:AllocatePrefetchStepSize=size
Sets the step size (in bytes) for sequential prefetch instructions. Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to indicate gigabytes. By default, the
step size is set to 16 bytes:
-XX:AllocatePrefetchStepSize=16
Only the Java HotSpot Server VM supports this option.
-XX:AllocatePrefetchStyle=style
Sets the generated code style for prefetch instructions. The style argument is an integer from 0 to 3:
0
Do not generate prefetch instructions.
1
Execute prefetch instructions after each allocation. This is the default parameter.
2
Use the thread-local allocation block (TLAB) watermark pointer to determine when prefetch instructions are executed.
3
Use BIS instruction on SPARC for allocation prefetch.
Only the Java HotSpot Server VM supports this option.
-XX:+BackgroundCompilation
Enables background compilation. This option is enabled by default. To disable background compilation, specify -XX:-BackgroundCompilation (this is equivalent to specifying -Xbatch).
-XX:CICompilerCount=threads
Sets the number of compiler threads to use for compilation. By default, the number of threads is set to 2 for the server JVM, to 1 for the client JVM, and it scales to the number of cores if
tiered compilation is used. The following example shows how to set the number of threads to 2:
-XX:CICompilerCount=2
-XX:CodeCacheMinimumFreeSpace=size
Sets the minimum free space (in bytes) required for compilation. Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to indicate gigabytes. When less than the
minimum free space remains, compiling stops. By default, this option is set to 500 KB. The following example shows how to set the minimum free space to 1024 MB:
-XX:CodeCacheMinimumFreeSpace=1024m
-XX:CompileCommand=command,method[,option]
Specifies a command to perform on a method. For example, to exclude the indexOf() method of the String class from being compiled, use the following:
-XX:CompileCommand=exclude,java/lang/String.indexOf
Note that the full class name is specified, including all packages and subpackages separated by a slash (/). For easier cut and paste operations, it is also possible to use the method name
format produced by the -XX:+PrintCompilation and -XX:+LogCompilation options:
-XX:CompileCommand=exclude,java.lang.String::indexOf
If the method is specified without the signature, the command will be applied to all methods with the specified name. However, you can also specify the signature of the method in the class file
format. In this case, you should enclose the arguments in quotation marks, because otherwise the shell treats the semicolon as command end. For example, if you want to exclude only the
indexOf(String) method of the String class from being compiled, use the following:
-XX:CompileCommand="exclude,java/lang/String.indexOf,(Ljava/lang/String;)I"
You can also use the asterisk (*) as a wildcard for class and method names. For example, to exclude all indexOf() methods in all classes from being compiled, use the following:
-XX:CompileCommand=exclude,*.indexOf
The commas and periods are aliases for spaces, making it easier to pass compiler commands through a shell. You can pass arguments to -XX:CompileCommand using spaces as separators by enclosing
the argument in quotation marks:
-XX:CompileCommand="exclude java/lang/String indexOf"
Note that after parsing the commands passed on the command line using the -XX:CompileCommand options, the JIT compiler then reads commands from the .hotspot_compiler file. You can add commands
to this file or specify a different file using the -XX:CompileCommandFile option.
To add several commands, either specify the -XX:CompileCommand option multiple times, or separate each argument with the newline separator (\n). The following commands are available:
break
Set a breakpoint when debugging the JVM to stop at the beginning of compilation of the specified method.
compileonly
Exclude all methods from compilation except for the specified method. As an alternative, you can use the -XX:CompileOnly option, which allows to specify several methods.
dontinline
Prevent inlining of the specified method.
exclude
Exclude the specified method from compilation.
help
Print a help message for the -XX:CompileCommand option.
inline
Attempt to inline the specified method.
log
Exclude compilation logging (with the -XX:+LogCompilation option) for all methods except for the specified method. By default, logging is performed for all compiled methods.
option
This command can be used to pass a JIT compilation option to the specified method in place of the last argument (option). The compilation option is set at the end, after the method name. For
example, to enable the BlockLayoutByFrequency option for the append() method of the StringBuffer class, use the following:
-XX:CompileCommand=option,java/lang/StringBuffer.append,BlockLayoutByFrequency
You can specify multiple compilation options, separated by commas or spaces.
print
Print generated assembler code after compilation of the specified method.
quiet
Do not print the compile commands. By default, the commands that you specify with the -XX:CompileCommand option are printed; for example, if you exclude from compilation the indexOf() method
of the String class, then the following will be printed to standard output:
CompilerOracle: exclude java/lang/String.indexOf
You can suppress this by specifying the -XX:CompileCommand=quiet option before other -XX:CompileCommand options.
-XX:CompileCommandFile=filename
Sets the file from which JIT compiler commands are read. By default, the .hotspot_compiler file is used to store commands performed by the JIT compiler.
Each line in the command file represents a command, a class name, and a method name for which the command is used. For example, this line prints assembly code for the toString() method of the
String class:
print java/lang/String toString
For more information about specifying the commands for the JIT compiler to perform on methods, see the -XX:CompileCommand option.
-XX:CompileOnly=methods
Sets the list of methods (separated by commas) to which compilation should be restricted. Only the specified methods will be compiled. Specify each method with the full class name (including the
packages and subpackages). For example, to compile only the length() method of the String class and the size() method of the List class, use the following:
-XX:CompileOnly=java/lang/String.length,java/util/List.size
Note that the full class name is specified, including all packages and subpackages separated by a slash (/). For easier cut and paste operations, it is also possible to use the method name
format produced by the -XX:+PrintCompilation and -XX:+LogCompilation options:
-XX:CompileOnly=java.lang.String::length,java.util.List::size
Although wildcards are not supported, you can specify only the class or package name to compile all methods in that class or package, as well as specify just the method to compile methods with
this name in any class:
-XX:CompileOnly=java/lang/String
-XX:CompileOnly=java/lang
-XX:CompileOnly=.length
-XX:CompileThreshold=invocations
Sets the number of interpreted method invocations before compilation. By default, in the server JVM, the JIT compiler performs 10,000 interpreted method invocations to gather information for
efficient compilation. For the client JVM, the default setting is 1,500 invocations. This option is ignored when tiered compilation is enabled; see the option -XX:+TieredCompilation. The
following example shows how to set the number of interpreted method invocations to 5,000:
-XX:CompileThreshold=5000
You can completely disable interpretation of Java methods before compilation by specifying the -Xcomp option.
-XX:+DoEscapeAnalysis
Enables the use of escape analysis. This option is enabled by default. To disable the use of escape analysis, specify -XX:-DoEscapeAnalysis. Only the Java HotSpot Server VM supports this option.
-XX:InitialCodeCacheSize=size
Sets the initial code cache size (in bytes). Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to indicate gigabytes. The default value is set to 500 KB. The
initial code cache size should be not less than the system's minimal memory page size. The following example shows how to set the initial code cache size to 32 KB:
-XX:InitialCodeCacheSize=32k
-XX:+Inline
Enables method inlining. This option is enabled by default to increase performance. To disable method inlining, specify -XX:-Inline.
-XX:InlineSmallCode=size
Sets the maximum code size (in bytes) for compiled methods that should be inlined. Append the letter k or K to indicate kilobytes, m or M to indicate megabytes, g or G to indicate gigabytes.
Only compiled methods with the size smaller than the specified size will be inlined. By default, the maximum code size is set to 1000 bytes:
-XX:InlineSmallCode=1000
-XX:+LogCompilation
Enables logging of compilation activity to a file named hotspot.log in the current working directory. You can specify a different log file path and name using the -XX:LogFile option.
By default, this option is disabled and compilation activity is not logged. The -XX:+LogCompilation option has to be used together with the -XX:UnlockDiagnosticVMOptions option that unlocks
diagnostic JVM op