java

java(1)                     General Commands Manual                    java(1)



Name
       java - the Java application launcher

SYNOPSIS
       java [ options ] class [ argument ... ]
       java [ options ] -jar file.jar [ argument ... ]


          options
             Command-line options. See Options.

          class
             The name of the class to be called.

          file.jar
             The name of the JAR file to be called. Used only with the -jar
             command.

          argument
             The arguments passed to the main function.


DESCRIPTION
       The java command starts a Java application. It does this by starting a
       Java runtime environment, loading a 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[])


       By default, the first argument without an option is the name of the
       class to be called. A fully qualified class name should be used. If the
       -jar option is specified, then the first non-option argument is the
       name of a JAR file containing class and resource files for the
       application, with the startup class indicated by the Main-Class
       manifest header.

       The Java runtime searches for the startup class, and other classes
       used, in three sets of locations: the bootstrap class path, the
       installed extensions, and the user class path.

       Non-option arguments after the class name or JAR file name are passed
       to the main function.

OPTIONS
       The launcher has a set of standard options that are supported in the
       current runtime environment.

       In addition, the current implementations of the virtual machines
       support a set of nonstandard options that are subject to change in
       future releases. See Nonstandard Options.

   Standard Options
          -client
             Selects the Java HotSpot Client VM. A 64-bit capable JDK
             currently ignores this option and instead uses the Java Hotspot
             Server VM.
             For default Java VM selection, see Server-Class Machine Detection
             at
             http://docs.oracle.com/javase/7/docs/technotes/guides/vm/server-class.html

          -server
             Selects the Java HotSpot Server VM. On a 64-bit capable JDK, only
             the Java Hotspot Server VM is supported so the -server option is
             implicit.
             For default a Java VM selection, see Server-Class Machine
             Detection at
             http://docs.oracle.com/javase/7/docs/technotes/guides/vm/server-class.html

          -agentlib:libname[=options]
             Loads native agent library libname, for example:
             -agentlib:hprof

             -agentlib:jdwp=help

             -agentlib:hprof=help
             See JVMTI Agent Command-Line Options at
             http://docs.oracle.com/javase/7/docs/platform/jvmti/jvmti.html#starting

          -agentpath:pathname[=options]
             Loads a native agent library by full pathname. See JVMTI
             Command-Line Options at
             http://docs.oracle.com/javase/7/docs/platform/jvmti/jvmti.html#starting

          -classpath classpath, -cp classpath
             Specifies a list of directories, JAR files, and ZIP archives to
             search for class files. Separate class path entries with colons
             (:). Specifying -classpath or -cp overrides any setting of the
             CLASSPATH environment variable.
             If -classpath and -cp are not used and CLASSPATH is not set, then
             the user class path consists of the current directory (.).
             As a special convenience, a class path element that contains a
             base name of * is considered equivalent to specifying a list of
             all the files in the directory with the extension .jar or .JAR. A
             Java program cannot tell the difference between the two
             invocations.
             For example, if directory mydir contains a.jar and b.JAR, then
             the class path element mydir/* is expanded to a A.jar:b.JAR,
             except that the order of jar files is unspecified. All jar files
             in the specified directory, even hidden ones, are included in the
             list. A class path entry consisting simply of * expands to a list
             of all the jar files in the current directory. The CLASSPATH
             environment variable, where defined, will be similarly expanded.
             Any class path wildcard expansion occurs before the Java VM is
             started. No Java program will ever see wild cards that are not
             expanded except by querying the environment. For example, by
             calling System.getenv("CLASSPATH").

          -Dproperty=value
             Sets a system property value.

          -d32
             Run the application in a 32-bit environment. If a 32-bit
             environment is not installed or is not supported, an error will
             be reported. By default, the application is run in a 32-bit
             environment unless a 64-bit only system is used.

          -d64
             Run the application in a 64-bit environment. If a 64-bit
             environment is not installed or is not supported, an error will
             be reported. By default, the application is run in a 32-bit
             environment unless a 64-bit only 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[:package name"..." | :class name ], -da[:package
          name"..." | :class name ]
             Disable assertions. This is the default.
             With no arguments, -disableassertions or -da disables assertions.
             With one argument ending in "...", the switch disables assertions
             in the specified package and any subpackages. If the argument is
             "...", then the switch disables assertions in the unnamed package
             in the current working directory. With one argument not ending in
             "...", the switch disables assertions in the specified class.
             To run a program with assertions enabled in package
             com.wombat.fruitbat but disabled in class
             com.wombat.fruitbat.Brickbat, the following command could be
             used:
             java -ea:com.wombat.fruitbat... -da:com.wombat.fruitbat.Brickbat <Main Class>
             The -disableassertions and -da switches apply to all class
             loaders and to system classes (which do not have a class loader).
             There is one exception to this rule: in their no-argument form,
             the switches do not apply to system. This makes it easy to turn
             on asserts in all classes except for system classes. The
             -disablesystemassertions option provides a separate swith to
             enable assertions in all system classes.

          -enableassertions[:package name"..." | :class name ], -ea[:package
          name"..." | :class name ]
             Enable assertions. Assertions are disabled by default.
             With no arguments, -enableassertions or -ea enables assertions.
             With one argument ending in "...", the switch enables assertions
             in the specified package and any subpackages. If the argument is
             "...", then the switch enables assertions in the unnamed package
             in the current working directory. With one argument not ending in
             "...", the switch enables assertions in the specified class.
             If a single command contains multiple instances of these
             switches, then they are processed in order before loading any
             classes. So, for example, to run a program with assertions
             enabled only in package com.wombat.fruitbat (and any
             subpackages), the following command could be used:
             java -ea:com.wombat.fruitbat... <Main Class>
             The -enableassertions and -ea switches apply to all class loaders
             and to system classes (which do not have a class loader). There
             is one exception to this rule: in their no-argument form, the
             switches do not apply to system. This makes it easy to turn on
             asserts in all classes except for system classes. The
             -enablesystemassertions option provides a separate switch to
             enable assertions in all system classes.

          -enablesystemassertions, -esa
             Enable assertions in all system classes (sets the default
             assertion status for system classes to true).

          -disablesystemassertions, -dsa
             Disables assertions in all system classes.

          -help or -?
             Displays usage information and exit.

          -jar
             Executes a program encapsulated in a JAR file. The first argument
             is the name of a JAR file instead of a startup class name. For
             this option to work, the manifest of the JAR file must contain a
             line in the form Main-Class: classname. Here, classname
             identifies the class with the public static void main(String[]
             args) method that serves as your application's starting point.
             When you use this option, the JAR file is the source of all user
             classes, and other user class path settings are ignored.
             JAR files that can be run with the java -jar option can have
             their execute permissions set so they can be run without using
             java -jar. See JAR File Overview at
             http://docs.oracle.com/javase/7/docs/technotes/guides/jar/jarGuide.html

          -javaagent:jarpath[=options]
             Loads a 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/7/docs/api/java/lang/instrument/package-summary.html
             @
             http://docs.oracle.com/javase/7/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 in the version search.

          -showversion
             Displays version information and continues.

          -splash:imagepath
             Shows splash screen with image specified by imagepath.

          -verbose, -verbose:class
             Displays information about each class loaded.

          -verbose:gc
             Reports on each garbage collection event.

          -verbose:jni
             Reports information about use of native methods and other Java
             Native Interface activity.

          -version
             Displays version information and exits. See also the -showversion
             option.

          -version:release
             Specifies that the version specified by the release is required
             by the class or JAR file specified on the command line. 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 option specifies an exact version and a list of
             versions called a version string. A version string is an ordered
             list of version ranges separated by spaces. A version range is
             either a version-id, a version-id followed by an asterisk (*), a
             version-id followed by a plus sign (+), or a version range that
             consists of two version-ids combined using an ampersand (&). The
             asterisk means prefix match, the plus sign means this version or
             greater, and the ampersand means the logical and of the two
             version-ranges, for example:
             -version:"1.6.0_13 1.6*&1.6.0_10+"
             The meaning of the previous example is that the class or JAR file
             requires either version 1.6.0_13, or a version with 1.6 as a
             version-id prefix and that is not less than 1.6.0_10. The exact
             syntax and definition of version strings can be found in Appendix
             A of the Java Network Launching Protocol & API Specification
             (JSR-56).
             For JAR files, the preference is to specify version requirements
             in the JAR file manifest rather than on the command line.
             See Notes for important policy information on the use of this
             option.


   Non-Standard Options
          -X Displays information about nonstandard options and exits.

          -Xint
             Operates in interpreted-only mode. Compilation to native code is
             disabled, and all bytecode is executed by the interpreter. The
             performance benefits offered by the Java HotSpot Client VM
             adaptive compiler is not present in this mode.

          -Xbatch
             Disables background compilation. Typically, the Java VM 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.

          -Xbootclasspath:bootclasspath
             Specifies a colon-separated list of directories, JAR files, and
             ZIP archives to search for boot class files. These are used in
             place of the boot class files included in the Java platform JDK.
             Applications that use this option for the purpose of overriding a
             class in rt.jar should not be deployed because doing so would
             contravene the Java Runtime Environment binary code license.

          -Xbootclasspath/a:path
             Specifies a colon-separated path of directories, JAR files, and
             ZIP archives to append to the default bootstrap class path.

          -Xbootclasspath/p:path
             Specifies a colon-separated path of directories, JAR files, and
             ZIP archives to add in 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 Java Runtime
             Environment binary code license.

          -Xcheck:jni
             Performs additional checks for Java Native Interface (JNI)
             functions. Specifically, the Java Virtual Machine 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 Java
             Virtual Machine will terminate with a fatal error in such cases.
             Expect a performance degradation when this option is used.

          -Xfuture
             Performs strict class-file format checks. For backward
             compatibility, the default format checks performed by the Java
             virtual machine are no stricter than the checks performed by
             1.1.x versions of the JDK software. The -Xfuture option turns on
             stricter class-file format checks that enforce closer 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 of the Java
             application launcher.

          -Xnoclassgc
             Disables class garbage collection. Use of this option preven
             memory recovery from loaded classes thus increasing overall
             memory usage. This could cause OutOfMemoryError to be thrown in
             some applications.

          -Xincgc
             Enables the incremental garbage collector. The incremental
             garbage collector, which is turned off by default, will reduce
             the occasional long garbage-collection pauses during program
             execution. The incremental garbage collector will at times
             execute concurrently with the program and during such times will
             reduce the processor capacity available to the program.

          -Xloggc:file
             Reports on each garbage collection event, as with -verbose:gc,
             but logs this data to a file. In addition to the information
             -verbose:gc gives, each reported event will be preceded by the
             time (in seconds) since the first garbage-collection event.
             Always use a local file system for storage of this file to avoid
             stalling the Java VM due to network latency. The file may be
             truncated in the case of a full file system and logging will
             continue on the truncated file. This option overrides -verbose:gc
             when both are specified on the command line.

          -Xmnsize or -XX:NewSize
             Sets the size of the young generation (nursery).

          -Xmsn
             Specifies the initial size, in bytes, of the memory allocation
             pool. This value must be a multiple of 1024 greater than 1 MB.
             Append the letter k or K to indicate kilobytes, or m or M to
             indicate megabytes. The default value is chosen at runtime based
             on system configuration. See Garbage Collector Ergonomics at
             http://docs.oracle.com/javase/7/docs/technotes/guides/vm/gc-ergonomics.html
             Examples:
             -Xms6291456
             -Xms6144k
             -Xms6m

          -Xmxn
             Specifies the maximum size, in bytes, of the memory allocation
             pool. This value must a multiple of 1024 greater than 2 MB.
             Append the letter k or K to indicate kilobytes, or m or M to
             indicate megabytes. 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 Garbage Collector Ergonomics at
             http://docs.oracle.com/javase/7/docs/technotes/guides/vm/gc-ergonomics.html
             Examples:
             -Xmx83886080
             -Xmx81920k
             -Xmx80m
             On Solaris 7 and Solaris 8 SPARC platforms, the upper limit for
             this value is approximately 4000 m minus overhead amounts. On
             Solaris 2.6 and x86 platforms, the upper limit is approximately
             2000 m minus overhead amounts. On Linux platforms, the upper
             limit is approximately 2000 m minus overhead amounts.

          -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 use of operating-system signals by the Java VM.
             In an earlier release, the Shutdown Hooks facility was added to
             enable orderly shutdown of a Java application. The intent was to
             enable user cleanup code (such as closing database connections)
             to run at shutdown, even if the Java VM terminates abruptly.
             The Java VM catches signals to implement shutdown hooks for
             unexpected Java VM termination. The Java VM 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 Java VM frequently need to trap
             signals such as SIGINT or SIGTERM, which can lead to interference
             with the Java VM signal handlers. The -Xrs command-line option is
             available to address this issue. When -Xrs is used on the Java
             VM, the signal masks for SIGINT, SIGTERM, SIGHUP, and SIGQUIT are
             not changed by the Java VM, and signal handlers for these signals
             are not installed.
             There are two consequences of specifying -Xrs:

             o SIGQUIT thread dumps are not available.

             o User code is responsible for causing shutdown hooks to run, for
               example by calling System.exit() when the Java VM is to be
               terminated.

          -Xssn
             Sets the thread stack size.

          -XX:AllocationPrefetchStyle=n
             Sets the style of prefetch used during allocation. default=2.

          -XX:+AggressiveOpts
             Enables aggressive optimization.

          -XX:+|-DisableAttachMechanism
             Specifies whether commands (such as jmap and jconsole) can attach
             to the Java VM. By default, this feature is disabled. That is,
             attaching is enabled, for example:
             java -XX:+DisableAttachMechanism

          -XXLargePageSizeInBytes=n
             Specifies the maximum size for large pages.

          -XX:MaxGCPauseMillis=n
             Sets a target for the maximum GC pause time.
             This is a soft goal, and the Java VM will make its best effort to
             achieve it. There is no maximum value set by default.

          -XX:NewSize
             Sets the size of the young generation (nursery). Sames as
             -Xmnsize.

          -XX:ParallelGCThreads=n
             Sets the number of GC threads in the parallel collectors.

          -XX:PredictedClassLoadCount=n
             This option requires that the UnlockExperimentalVMOptions flag be
             set first. Use the PredictedClassLoadCount flag if your
             application loads a lot of classes and especially if
             class.forName() is used heavily. The recommended value is the
             number of classes loaded as shown in the output from
             -verbose:class.
             Example:
             java -XX:+UnlockExperimentalVMOptions -XX:PredictedClassLoadCount=60013

          -XX:+PrintCompilation
             Prints verbose output from the Java HotSpot VM dynamic runtime
             compiler.

          -XX:+PrintGCDetails -XX:+PrintGCTimeStamps
             Prints garbage collection output along with time stamps.

          -XX:SoftRefLRUPolicyMSPerMB=0
             This flag enables aggressive processing of software references.
             Use this flag if the software reference count has an impact on
             the Java HotSpot VM garbage collector.

          -XX:TLABSize=n
             Thread local allocation buffers (TLAB) are enabled by default in
             the Java HotSpot VM. The Java HotSpot VM sizes TLABs based on
             allocation patterns. The -XX:TLABSize option enables fine-tuning
             the size of TLABs.

          -XX:+UseAltSigs
             The Java VM uses SIGUSR1 and SIGUSR2 by default, which can
             sometimes conflict with applications that signal-chain SIGUSR1
             and SIGUSR2. The -XX:+UseAltSigs option causes the Java VM to use
             signals other than SIGUSR1 and SIGUSR2 as the default.

          -XX:+|-UseCompressedOops
             Enables compressed references in 64-bit Java VMs.
             This option is true by default.

          -XX:+UseConcMarkSweepGC or -XX:+UseG1GC
             Enables either the Concurrent Mark Sweep (CMS) or the G1 garbage
             collectors.

          -XX:+|-UseLargePages
             Enables large page support.
             Large pages are enabled by default on Solaris.

          -XX:+UseParallelOldGC
             Enables the parallel garbage collectors, which are optimized for
             throughput and average response time.


NOTES
       The -version:release option places no restrictions on the complexity of
       the release specification. However, only a restricted subset of the
       possible release specifications represent sound policy and only these
       are fully supported. These policies are:

          1. Any version, represented by not using this option.

          2. Any version greater than an arbitrarily precise version-id value,
             for example:
             "1.6.0_10+"
             This would utilize any version greater than 1.6.0_10. This is
             useful for a case where an interface was introduced (or a bug
             fixed) in the release specified.

          3. A version greater than an arbitrarily precise version-id, bounded
             by the upper bound of that release family, for example:
             "1.6.0_10+&1.6*"

          4. An or expressions of items 2 or 3, for example:
             "1.6.0_10+&1.6* 1.7+"
             Similar to item 2. This is useful when a change was introduced in
             a release (1.7) but also made available in updates to earlier
             releases.


Performance Tuning Examples
       The following examples show how to use experimental tuning flags to
       optimize either throughput or faster response time.

   Example 1, Tuning for Higher Throughput
               java -d64 -server -XX:+AggressiveOpts -XX:+UseLargePages -Xmn10g  -Xms26g -Xmx26g


   Example 2, Tuning for Lower Response Time
               java -d64 -XX:+UseG1GC -Xms26g Xmx26g -XX:MaxGCPauseMillis=500 -XX:+PrintGCTimeStamps


EXIT STATUS
       The following exit values are typically returned by the launcher,
       typically when the launcher is called with the wrong arguments, serious
       errors, or exceptions thrown from the Java Virtual Machine. However, a
       Java application may choose to return any value using the API call
       System.exit(exitValue).

          o 0: Successful completion

          o >0: An error occurred


SEE ALSO
          o javac(1)

          o jdb(1)

          o javah(1)

          o jar(1)


                                  18 Jul 2013                          java(1)