ALT-JAVA-JAVA-1.8.0-OPENJDK-1.8.0.504.B01-2.1.EL9.X86_64-FASTDEBUG(1)

📦 version 1.8.0.504.b01, in centos-stream 9

🌈 `java(1)` — Basic Tools 🌈

Hardened java binary recommended for launching untrusted code from the Web e.g. javaws 🫶

Okay bestie, this is the java(1) manual page, and it is literally the main-character launch command for Java apps. ✨

🌸 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. That 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 this exact 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. Don’t forget it exists, bestie.

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. Slay.

-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, bestie. 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`

Bestie, this is the one everyone asks about 💅 — it sets the maximum size, in bytes, of the memory allocation pool (the heap, basically the JVM's bag of holding 🎒). Rules, and yes there are rules:

It has to be a multiple of 1024 and greater than 2 MB. No vibes-only guessing, the JVM will check you.
Append k or K for kilobytes, m or M for megabytes, or g or G for gigabytes.
The default value is chosen at runtime based on system configuration — so it's not a fixed number, she decides at launch ✨
For server deployments, -Xms and -Xmx are often set to the same value. Iconic matching-set behavior 🫶

There's also a whole section called "Ergonomics" in the Java SE HotSpot Virtual Machine Garbage Collection Tuning Guide at http://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/index.html — that's the reading material if you want the deep lore 📚

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. Same energy, different name, iykyk ✨

`-Xnoclassgc`

Disables garbage collection (GC) of classes. Not me turning off the class janitor 😭 — this can save some GC time, which shortens interruptions during the application run. Nice.

Here's the catch though: when you specify -Xnoclassgc at startup, the class objects in the application will be left untouched during GC and will always be considered live. That can result in more memory being permanently occupied which, if not used carefully, will throw an out of memory exception. So like… cute but dangerous, lowkey a red-flag option 🚩

`-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. So she's a dev-only girly, do not bring her to the production party 🎀

`-Xrs`

Reduces the use of operating system signals by the JVM. Let's break this down, bestie, because signal lore is actually kind of fascinating 👑

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. Very responsible, very main character 🫶

The JVM catches signals to implement shutdown hooks for unexpected termination. Specifically, 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.

Now here's the plot twist 😭 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.

So yeah — no more SIGQUIT dumps, and the cleanup era is on you now. Know what you're signing up for 💀

`-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. All-or-nothing, respect ✨
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".

Heads up 🎀 — you should regenerate the CDS archive with each new JDK release. New JDK, new archive, that's the rule.

`-XshowSettings:category`

Shows settings and continues. She doesn't stop the run, she just shows you the fit check first 💅 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 k or K to indicate KB, m or M to indicate MB, or 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. Same stack, different label 🌸

`-Xusealtsigs`

Use alternative signals instead of SIGUSR1 and SIGUSR2 for JVM internal signals. This option is equivalent to -XX:+UseAltSigs. Sometimes you just gotta pick different signals, no cap 💅

`-Xverify:mode`

Sets the mode of the bytecode verifier. Bytecode verification helps to troubleshoot some problems, but it also adds overhead to the running application — so it's giving "safety but make it expensive" 😭 Possible mode arguments for this option include the following:

none — Do not verify the bytecode. This reduces startup time and also reduces the protection provided by Java. Faster, sure, but you're kinda out here raw-dogging bytecode 🚩
remote — Verify those classes that are not loaded by the bootstrap class loader. This is the default behavior if you do not specify the -Xverify option.
all — Verify all classes. Full protective era, love that for security 🫶

✨ Advanced Runtime Options ✨

These options control the runtime behavior of the Java HotSpot VM. Advanced mode unlocked 🔓

`-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.

Basically a whole background check for your classpath 🕵️‍♀️

`-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. So the tooling girlies stay welcome unless you explicitly slam the door 🔥

`-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. Fallback queen 👑

`-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. Retro vibes only, bestie 🎀

`-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 k or K to indicate kilobytes, m or M to indicate megabytes, or 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 k or K to indicate kilobytes, m or M to indicate megabytes, or 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. She's thorough 💅

`-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. So like… bigger alignment, bigger gaps, less payoff 😭 math stays mathing.

`-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"

Emergency contact list for when things go full 💀 — honestly kind of iconic.

-XX:OnOutOfMemoryError=string** **— sets a custom command, or a whole series of commands separated by semicolons, to run the very first time an OutOfMemoryError exception gets thrown. Bestie, if your string has spaces in it, wrap it in quotation marks or it's not gonna parse. Want an example command string? Go peek at the description of the -XX:OnError option, iykyk.
-XX:+PerfDataSaveToFile — if you turn this on, it saves jstat(1) binary data when the Java application exits. That binary data lands in a file named hsperfdata_<pid>, where <pid> is the process identifier of the Java application you ran. Then you use jstat to display the performance data inside it like this:

jstat -class file:///<path>/hsperfdata_<pid>
jstat -gc file:///<path>/hsperfdata_<pid>

-XX:+PrintCommandLineFlags — turns on printing of the ergonomically selected JVM flags that appeared on the command line. Honestly so useful for knowing the ergonomic values the JVM picked for you, like the heap space size and the selected garbage collector. By default this option is disabled and flags are not printed. 🙈
-XX:+PrintNMTStatistics — turns on printing of the collected native memory tracking data at JVM exit, but only when native memory tracking is enabled (see -XX:NativeMemoryTracking). By default it's disabled and native memory tracking data is not printed.
-XX:+RelaxAccessControlCheck — decreases the amount of access control checks in the verifier. By default it's disabled, and it's ignored (like, treated as disabled) for classes with a recent bytecode version. You can enable it for classes with older versions of the bytecode. 💅
-XX:+ShowMessageBoxOnError — enables displaying a dialog box when the JVM experiences an irrecoverable error. This one is lowkey iconic: it stops the JVM from exiting and keeps the process active so you can attach a debugger to it and investigate the cause of the error. By default this option is disabled.
-XX:ThreadStackSize=size** **— sets the thread stack size, in bytes. Append the letter k or K for kilobytes, m or M for megabytes, g or G for 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

Here's how you'd set the thread stack size to 1024 KB in different units, bestie:

-XX:ThreadStackSize=1m
-XX:ThreadStackSize=1024k
-XX:ThreadStackSize=1048576

This option is equivalent to -Xss. Slay.

-XX:+TraceClassLoading — enables tracing of classes as they are loaded. By default it's disabled and classes are not traced.
-XX:+TraceClassLoadingPreorder — enables tracing of all loaded classes in the order in which they are referenced. By default it's disabled and classes are not traced.
-XX:+TraceClassResolution — enables tracing of constant pool resolutions. By default it's disabled and constant pool resolutions are not traced.
-XX:+TraceClassUnloading — enables tracing of classes as they are unloaded. By default it's disabled and classes are not traced. 🦋
-XX:+TraceLoaderConstraints — enables tracing of the loader constraints recording. By default it's disabled and loader constraints recording is not traced.
-XX:+UseAltSigs — enables the use of alternative signals instead of SIGUSR1 and SIGUSR2 for JVM internal signals. By default it's disabled and alternative signals are not used. This option is equivalent to -Xusealtsigs.
-XX:-UseBiasedLocking — disables the use of biased locking. Heads up: 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 info 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. (Yes, the flag above is the disable form — the way that works is genuinely a whole vibe. 🫶)

-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's 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. It's 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 that 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. Like, seriously, don't. 💀)
-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. Ngl 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. Main character energy fr fr.

-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