站内搜索: 请输入搜索关键词
当前页面: 在线文档首页 > JDK 5 Documentation v1.1.8, Java 2 SDK 英文文档

java - The Java Application Launcher - JDK 5 Documentation v1.1.8, Java 2 SDK 英文文档

java - The Java Interpreter

java launches a Java application.

SYNOPSIS

   java [ options ] classname <args>
   java_g [ options ] classname <args>
   javaw [ options ] classname <args>
   javaw_g [ options ] classname <args>

DESCRIPTION

The java program launches a Java application. It does this by starting a Java runtime environment, loading a specified class, and invoking that class's main method. The java command executes Java .class files created by a Java compiler, for instance, javac. The javaw command is identical to java, except that with javaw there is no associated console window. Use javaw when you don't want a command prompt window to appear.

The classname argument is the name of the class to be executed. classname must be fully qualified by including its package in the name, for example: 

   % java java.lang.String
Note that any arguments that appear after classname on the command line are passed to the main method of the class.

java expects the binary representation of the class to be in a file called named after the class. Thus, class String would be in String.class which is generated by compiling the corresponding String.java source file with javac. All Java class files end with the filename extension .class which the compiler automatically adds when the class is compiled. classname must contain a main method defined as follows: 

   class Aclass {
       public static void main(String argv[]){ 
       . . .
       }
   }
java executes the main method and then exits unless main creates one or more threads. If any threads are created by main then java doesn't exit until the last thread exits.

When you define your own classes you need to specify their location. Use CLASSPATH to do this. CLASSPATH consists of a semicolon separated list of directories that specifies the path. For example: 

   .;C:\xyz\classes
Note that the system always appends the location of the system classes onto the end of the class path unless you use the -classpath option to specify a path.

The interpreter can determine whether a class is legitimate through the mechanism of verification. Verification ensures prior to their execution that class files do not violate any language constraints.

java_g is a non-optimized version of java suitable for use with debuggers like jdb. When using java_g to run a program that loads a shared library, you must supply a debug version of the library. You can create a debug version of a library by simply appending "_g" to the file's name. For example, if the library was hello.dll, you would need to change the name to hello_g.dll.

USING THE JIT

By default, each class file is compiled to native code by a Just In Time bytecode compiler, or JIT. Using the JIT can cause some delay in program startup and class file loading, but can also reduce overall program execution time by a factor of ten.

You can disable the JIT and use a bytecode interpreter instead. There are two ways to disable the JIT:

  • Use the command line option -nojit.

  • Set the the environment variable JAVA_COMPILER to "NONE".

The value of JAVA_COMPILER can also be the name of an alternate JIT. The launcher appends .DLL to the value, then searches for the resulting filename. The search begins in the executable directory (the same directory that contains JAVA.EXE), and continues with all directories in the PATH.

You can also specify an alternate JIT by specifying the java.compiler property: 

    java -Djava.compiler=myjit MyClass

If JIT options are specified both by the JAVA_COMPILER environment variable and by a command-line option, the command-line option takes precedence. If multiple command line options conflict, the last option takes precedence.

OPTIONS
-debug
Allows the Java debugger, jdb, to attach itself to this java session. When -debug is specified on the command line java displays a password which must be used when starting the debugging session.

-classpath path
Specifies the path java uses to look up classes. Overrides the default or the CLASSPATH environment variable if it is set. Directories are separated by semicolons. Thus the general format for path is: 
   .:<your_path>
For example: 
   C:\xyz\classes;C:\usr\local\java\classes

-mxx
Sets the maximum size of the memory allocation pool (the garbage collected heap) to x. The default is 16 megabytes of memory. x must be greater than or equal to 1000 bytes. The maximum memory size must be greater than or equal to the startup memory size (specified with the -ms option, default 16 megabytes).

By default, x is measured in bytes. You can specify x in either kilobytes or megabytes by appending the letter "k" for kilobytes or the letter "m" for megabytes.

-msx
Sets the startup size of the memory allocation pool (the garbage collected heap) to x. The default is 1 megabyte of memory. x must be > 1000 bytes. The startup memory size must be less than or equal to the maximum memory size (specified with the -mx option, default 16 megabytes).

By default, x is measured in bytes. You can specify x in either kilobytes or megabytes by appending the letter "k" for kilobytes or the letter "m" for megabytes.

-noasyncgc
Turns off asynchronous garbage collection. When activated no garbage collection takes place unless it is explicitly called or the program runs out of memory. Normally garbage collection runs as an asynchronous thread in parallel with other threads.

-noclassgc
Turns off garbage collection of Java classes. By default, the Java interpreter reclaims space for unused Java classes during garbage collection.

-nojit
Don't invoke the Just In Time bytecode compiler. The virtual machine directly interprets bytecodes, without converting them to native code. See Using the JIT, above.

-prof
Starts the Java Runtime with Java profiling enabled. By default, this puts profile results in the file .\java.prof. This option works only with java_g and javaw_g.

-prof:file
Starts the Java Runtime with Java profiling enabled. This form of the flag allows the user to specify a different output file for the profile information. For example, the flag -prof:myprog.prof enables profiling and puts the profile results in the file myprog.prof rather than in the default file .\java.prof. This option works only with java_g and javaw_g.

-version
Print the build version information.

-help
Print a usage message.

-ssx
Each Java thread has two stacks: one for Java code and one for C code. The -ss option sets the maximum stack size that can be used by C code in a thread to x. Every thread that is spawned during the execution of the program passed to java has x as its C stack size. The default units for x are bytes. The value of x must be greater than or equal to 1000 bytes.

You can modify the meaning of x by appending either the letter "k" for kilobytes or the letter "m" for megabytes. The default stack size is 128 kilobytes ("-ss128k").

-ossx
Each Java thread has two stacks: one for Java code and one for C code. The -oss option sets the maximum stack size that can be used by Java code in a thread to x. Every thread that is spawned during the execution of the program passed to java has x as its Java stack size. The default units for x are bytes. The value of x must be greater than or equal to 1000 bytes.

You can modify the meaning of x by appending either the letter "k" for kilobytes or the letter "m" for megabytes. The default stack size is 400 kilobytes ("-oss400k").

-t
Prints a trace of the instructions executed (java_g only).

-v, -verbose
Causes java to print a message to stdout each time a class file is loaded.

-verify
Performs byte-code verification on the class file. Beware, however, that java -verify does not perform a full verification in all situations. Any code path that is not actually executed by the interpreter is not verified. Therefore, java -verify cannot be relied upon to certify class files unless all code paths in the class file are actually run.

-verifyremote
Runs the verifier on all code that is loaded into the system via a classloader. verifyremote is the default for the interpreter.

-noverify
Turns verification off.

-verbosegc
Causes the garbage collector to print out messages whenever it frees memory.

-DpropertyName=newValue
Redefines a property value. propertyName is the name of the property whose value you want to change and newValue is the value to change it to. For example, this command line 
   % java -Dawt.button.color=green ...
sets the value of the property awt.button.color to "green". java accepts any number of -D options on the command line.

Options for Control of Heap Expansion and Shrinkage

The following options, introduced in version 1.1.8 of the Java Development Kit, allow for user control of garbage-collected heap expansion and shrinkage. The default settings of the heap expansion and shrinkage parameters are appropriate for the majority of applications, so these options are not needed in most computing situations. You should not use them unless you understand the effect they will have on your application. Randomly setting these options is as likely to decrease the performance of your system as improve it. The effect of these options will be greatest if a JIT compiler is not being used. See also the heap shrinkage limitations below.
-maxesize
Sets the maximum size of each expansion of the heap when more memory is required. By default, size is measured in bytes. To specify size in either kilobytes or megabytes, append "k" for kilobytes or "m" for megabytes. The default value for the setting of maxe is 2 megabyte of memory. Example: 
java -maxe2097152 MyClass

-minesize
Sets the minimum size of each expansion of the heap. Also sets the minimum size of free object space in the heap. The heap will be returned to the OS only when the amount of free object space in the heap space is more than the setting of mine. By default, size is measured in bytes. To specify size in either kilobytes or megabytes, append "k" for kilobytes or "m" for megabytes. The default value for mine is 1 megabyte of memory. Example: 
java -mine1048576 MyClass

-maxffloat
Sets the approximate percentage of maximum free heap. If the percentage of free object space in the heap is more than the setting of maxf and the amount of free object space in the heap is more than the setting of mine, and free object space is located at the top of the heap, the garbage collector will attempt to shrink the heap by returning a portion of free object space back to the OS. The heap size will not shrink below its initial size. The default value for maxf is 1.00; by default no heap is returned back to the OS. Example: 
java -maxf0.60 MyClass

-minffloat
Sets the approximate percentage of minimum free space in the heap to give control over the rate of preallocation performed when heap space is expanded. After expansion, approximately minf percent of the heap should be free. The actual amount of free space in the space after expansion is dependent on the value of minf and fragmentation of free spaces within the heap. The default value for minf is 0.25. Example: 
java -minf0.35 MyClass

Heap Shrinkage Limitations: The amount heap shrinkage relies on using heap compaction to free up space at the end of the heap which is then de-committed to return it to the OS. The Java garbage collector is implemented using a compacting, mark-sweep collector with some conservative scanning. A gc is conservative if it does not collect memory that looks as if it might be in use on the stack or in registers.

The mark-sweep and conservative scanning phase of the garbage collector marks objects as being free, used and un-movable (pinned), or used and movable. After the objects have been marked, free space is garbage collected. The compacting phase of the garbage collector attempts to coalesce the movable objects to the low end of object space to reduce heap fragmentation.

If an object is un-movable (pinned), it cannot be moved during the compaction phase. If one of the pinned objects is near the top of the heap, and much of the free space is below it, the free space below the pinned object cannot be returned to the OS. If either the JIT compiler is enabled, or the Java Native Interface (JNI) API or native method interface is used to make C calls, the conservative scan phase of the garbage collector may see a value in memory created by the C code that looks like a pointer to an object and mark the object in the heap as "pinned" because it appears to be pointed to directly by native code.

ENVIRONMENT VARIABLES

CLASSPATH
Used to provide the system a path to user-defined classes. Directories are separated by semicolons, for example, 
   C:\xyz\classes;C:\usr\local\java\classes

JAVA_COMPILER
Overrides default JIT. See Using the JIT, above.

SEE ALSO

javac, jdb, javah, javap, javadoc, CLASSPATH