Java JVM Options

Su Suriya Ravichandran Updated 18 Nov 2026
14 min read ·Lesson 292 of 306

Java JVM options are command-line flags that control how the Java Virtual Machine runs your program: how much memory it may use, which garbage collector cleans that memory, what happens when memory runs out, and which settings your code can read. You pass them to the java command before the class or JAR name. The right JVM options make an application predictable in production; the wrong ones cause slow pauses or crashes.

This lesson explains the JVM options you will actually use, shows how to check which values are in effect, and ends with a production options file for the CourseServer app from Java Production Setup. All examples were run on JDK 21 on a Linux machine with 6 GB of RAM and 2 CPUs.


Java JVM Options Syntax: Standard, -X and -XX Flags

Every option goes before the main class or -jar. Anything after it is passed to your main(String[] args) instead.

java [JVM options] MainClass [program arguments]
java [JVM options] -jar app.jar [program arguments]
PrefixTypeExampleStability
-Standard option-cp, -jar, -version, -DSame on every JVM
-XExtra option-Xmx512m, -Xss1m, -Xlog:gcStable in HotSpot (OpenJDK)
-XX:+NameTurn a boolean flag on-XX:+UseG1GCHotSpot advanced flag
-XX:-NameTurn a boolean flag off-XX:-UseCompressedOopsHotSpot advanced flag
-XX:Name=valueSet a value-XX:MaxRAMPercentage=75HotSpot advanced flag
-Dname=valueSystem property for your code-Dapp.env=prodRead with System.getProperty

Sizes accept the suffixes k, m and g (case-insensitive): -Xmx512m, -Xmx2g, -Xss256k.

# correct: options before the class
java -Xmx512m MemoryInfo

# wrong: -Xmx512m becomes args[0] and the JVM ignores it
java MemoryInfo -Xmx512m

How it works:

  • The launcher reads options from left to right until it reaches the main class or -jar app.jar. Everything after that belongs to your program.
  • When the same option appears twice, the last one wins. java -Xmx256m -Xmx1g App runs with a 1 GB heap.

Set Java Heap Size With -Xms and -Xmx

The heap is the memory where your objects live. Two options control it:

OptionMeaningDefault
-Xms<size>Initial heap size, reserved at startup1/64 of physical RAM
-Xmx<size>Maximum heap size, the hard limit1/4 of physical RAM

This program prints the memory the JVM thinks it has:

public class MemoryInfo {
    public static void main(String[] args) {
        Runtime runtime = Runtime.getRuntime();
        long mb = 1024 * 1024;
        System.out.println("Processors : " + runtime.availableProcessors());
        System.out.println("Max heap   : " + runtime.maxMemory() / mb + " MB");
        System.out.println("Total heap : " + runtime.totalMemory() / mb + " MB");
        System.out.println("Free heap  : " + runtime.freeMemory() / mb + " MB");
    }
}
javac MemoryInfo.java
java MemoryInfo
java -Xms256m -Xmx512m MemoryInfo
Processors : 2
Max heap   : 1496 MB
Total heap : 96 MB
Free heap  : 94 MB

Processors : 2
Max heap   : 512 MB
Total heap : 258 MB
Free heap  : 255 MB

How it works:

  • Without options, the JVM picks a maximum of about 25% of RAM (1.5 GB of 6 GB here) and starts small (96 MB). It grows the heap only when needed.
  • maxMemory() reports -Xmx. totalMemory() is what is currently reserved, which starts at about -Xms.
  • freeMemory() is the unused part of the reserved heap, not of the whole machine.

Note: The heap is not the only memory Java uses. Thread stacks, loaded classes (metaspace), the JIT compiler and direct buffers live outside it. A JVM with -Xmx512m typically uses 650–800 MB of RAM in total, so leave room for that.

Size the Heap as a Percentage of RAM

In containers and on servers of different sizes, a percentage is easier to maintain than a fixed number.

java -XX:MaxRAMPercentage=50 MemoryInfo
Processors : 2
Max heap   : 2990 MB
Total heap : 96 MB
Free heap  : 94 MB
OptionMeaning
-XX:MaxRAMPercentage=75Max heap = 75% of available RAM (or the container memory limit)
-XX:InitialRAMPercentage=50Initial heap = 50% of available RAM

How it works:

  • The JVM detects the container memory limit, so in Docker --memory=1g with -XX:MaxRAMPercentage=75 gives a 768 MB heap, as used in Dockerize a Java Application.
  • -Xmx overrides the percentage options if both are given. Pick one style per application.

Check JVM Option Values With PrintFlagsFinal

Never guess which value a flag has. Two built-in options show it.

java -XshowSettings:vm -version
VM settings:
    Max. Heap Size (Estimated): 1.46G
    Using VM: OpenJDK 64-Bit Server VM

-XX:+PrintFlagsFinal prints every flag (more than 500) with its final value. Filter it with grep:

java -Xmx512m -XX:+PrintFlagsFinal -version | grep -E ' (MaxHeapSize|InitialHeapSize|UseG1GC|UseSerialGC|UseZGC|ThreadStackSize|MaxRAMPercentage) '
   size_t InitialHeapSize                          = 98566144                                  {product} {ergonomic}
   size_t MaxHeapSize                              = 536870912                                 {product} {command line}
   double MaxRAMPercentage                         = 25.000000                                 {product} {default}
     intx ThreadStackSize                          = 1024                                   {pd product} {default}
     bool UseG1GC                                  = true                                      {product} {ergonomic}
     bool UseSerialGC                              = false                                     {product} {default}
     bool UseZGC                                   = false                                     {product} {default}

How it works:

  • The last column says where each value came from: {command line} (you set it), {ergonomic} (the JVM chose it based on the machine) or {default}.
  • MaxHeapSize = 536870912 bytes is exactly 512 MB, confirming that -Xmx512m was applied.
  • -version makes the JVM print the flags and exit without running a program.

Choose a Garbage Collector

The garbage collector (GC) frees memory used by objects that are no longer reachable. HotSpot ships several, each with a different trade-off.

OptionCollectorBest forPause times
-XX:+UseSerialGCSerialTiny apps, 1 CPU, small heapsLongest, stops everything
-XX:+UseParallelGCParallelBatch jobs where throughput matters mostLong, but rare
-XX:+UseG1GCG1 (default)Most server applicationsShort, target 200 ms
-XX:+UseZGCZGCLarge heaps, low-latency APIsUnder 1 ms

This program creates a lot of short-lived garbage:

import java.util.ArrayList;
import java.util.List;

public class GcDemo {
    public static void main(String[] args) {
        List<String> batch = new ArrayList<>();
        for (int i = 0; i < 3_000_000; i++) {
            batch.add("order-" + i);              // short-lived garbage
            if (batch.size() == 100_000) batch.clear();
        }
        System.out.println("Done");
    }
}
java -Xmx128m -Xlog:gc GcDemo
java -Xmx128m -XX:+UseZGC -Xlog:gc GcDemo
[0.003s][info][gc] Using G1
[0.051s][info][gc] GC(0) Pause Young (Normal) (G1 Evacuation Pause) 7M->5M(96M) 4.133ms
[0.060s][info][gc] GC(1) Pause Young (Normal) (G1 Evacuation Pause) 8M->7M(96M) 1.827ms
[0.069s][info][gc] GC(2) Pause Young (Normal) (G1 Evacuation Pause) 15M->10M(96M) 3.326ms
[0.105s][info][gc] GC(3) Pause Young (Normal) (G1 Evacuation Pause) 64M->13M(96M) 3.078ms
...
Done

[0.011s][info][gc] Using The Z Garbage Collector
[0.263s][info][gc] GC(0) Garbage Collection (Warmup) 122M(95%)->12M(9%)
Done

How it works:

  • -Xlog:gc prints one line per collection. 64M->13M(96M) 3.078ms means the heap held 64 MB before the collection, 13 MB after, out of 96 MB reserved, and the pause took about 3 ms.
  • G1 is chosen automatically on server-class machines (2+ CPUs and 2+ GB RAM). On a 1-CPU container the JVM may pick Serial instead, so set -XX:+UseG1GC explicitly in production.
  • ZGC does most of its work while your threads keep running, so it reports cycles rather than long pauses. In JDK 21+ add -XX:+ZGenerational for the generational version; from JDK 23 it is the default ZGC mode.

Note: Start with G1 and change only when GC logs show a real problem. Switching collectors without measurements rarely helps.


Write GC Logs to a File

In production, GC logs go to a rotating file so you can investigate slowdowns after they happen.

-Xlog:<what>:<where>:<decorations>:<output options>
java -Xmx128m \
  -Xlog:gc*:file=logs/gc.log:time,uptime,level,tags:filecount=5,filesize=10m \
  GcDemo
head -n 3 logs/gc.log
Done
[2026-11-18T05:18:13.819+0000][0.004s][info][gc,init] CardTable entry size: 512
[2026-11-18T05:18:13.819+0000][0.004s][info][gc     ] Using G1
[2026-11-18T05:18:13.820+0000][0.006s][info][gc,init] Version: 21.0.12.1+1-1-24.04.4-Ubuntu (release)
PartValue hereMeaning
Whatgc*All GC-related tags (gc, gc,heap, gc,phases, ...)
Wherefile=logs/gc.logOutput file (stdout and stderr also work)
Decorationstime,uptime,level,tagsWall-clock time, JVM uptime, level, tags on each line
Output optionsfilecount=5,filesize=10mKeep 5 files of 10 MB each, then rotate

How it works:

  • gc* logs far more detail than gc, including the heap layout at startup and the time of each GC phase.
  • Rotation caps disk usage at 50 MB. The JVM renames gc.log to gc.log.0, gc.log.1 and so on.
  • The logs folder must exist before the JVM starts, or logging to the file fails with a warning.

Handle OutOfMemoryError Safely

When the heap is full and the GC cannot free enough space, the JVM throws java.lang.OutOfMemoryError. This program leaks memory on purpose:

import java.util.ArrayList;
import java.util.List;

public class LeakyCache {
    public static void main(String[] args) {
        List<byte[]> cache = new ArrayList<>();
        for (int i = 1; ; i++) {
            cache.add(new byte[1024 * 1024]); // 1 MB per entry, never removed
            if (i % 20 == 0) System.out.println("Cached " + i + " MB");
        }
    }
}
java -Xmx64m LeakyCache
Cached 20 MB
Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
	at LeakyCache.main(LeakyCache.java:8)

In a web server, only the thread that hit the error dies. The process keeps running in a broken state. Three options fix that:

mkdir -p dumps
java -Xmx64m \
  -XX:+HeapDumpOnOutOfMemoryError \
  -XX:HeapDumpPath=dumps \
  -XX:+ExitOnOutOfMemoryError \
  LeakyCache
echo "exit code: $?"
ls dumps
Cached 20 MB
java.lang.OutOfMemoryError: Java heap space
Dumping heap to dumps/java_pid403.hprof ...
Heap dump file created [36118832 bytes in 0.023 secs]
Terminating due to java.lang.OutOfMemoryError: Java heap space
exit code: 3
java_pid403.hprof
OptionEffect
-XX:+HeapDumpOnOutOfMemoryErrorWrites a snapshot of every object in the heap
-XX:HeapDumpPath=dumpsFolder (or file name) for the dump
-XX:+ExitOnOutOfMemoryErrorExits the JVM right after the first OOM
-XX:+CrashOnOutOfMemoryErrorLike Exit, but also writes a crash log (hs_err_pid*.log)

How it works:

  • The .hprof file can be opened in Eclipse MAT or VisualVM to see which objects filled the heap. Here it would show one ArrayList holding thousands of byte[].
  • Exit code 3 tells systemd or Docker that the process failed, so Restart=on-failure starts a fresh JVM within seconds.
  • Each byte array here is 1 MB, so G1 stores it as a "humongous" object in its own region. That is why the 64 MB heap fills after only about 20–30 entries.

Note: A heap dump is as large as the used heap and may contain passwords and personal data from memory. Put dumps on a disk with enough space and restrict who can read them.


Set the Thread Stack Size With -Xss

Each thread has its own stack for method calls and local variables. -Xss sets its size. Deep recursion fills it and throws StackOverflowError.

public class Recursion {
    static int depth = 0;

    static void dive() {
        depth++;
        dive();
    }

    public static void main(String[] args) {
        try {
            dive();
        } catch (StackOverflowError e) {
            System.out.println("Stack overflow at depth " + depth);
        }
    }
}
java Recursion
java -Xss256k Recursion
java -Xss4m Recursion
Stack overflow at depth 23306
Stack overflow at depth 3644
Stack overflow at depth 101948

How it works:

  • The default stack on 64-bit Linux is 1 MB (ThreadStackSize = 1024 in KB, from the earlier PrintFlagsFinal output).
  • A bigger stack allows deeper recursion, and a smaller one saves memory when you run thousands of platform threads. 1,000 threads × 1 MB = 1 GB of reserved stack space.
  • The exact depth changes from run to run because the JIT compiler changes how much stack each call needs.

Pass Settings to Your Code With -D System Properties

-Dname=value creates a system property that your code reads at runtime. It is the JVM-native way to pass configuration.

public class AppSettings {
    public static void main(String[] args) {
        String env = System.getProperty("app.env", "dev");
        int port = Integer.getInteger("app.port", 8080);
        boolean debug = Boolean.getBoolean("app.debug");
        System.out.println("env=" + env + ", port=" + port + ", debug=" + debug);
        System.out.println("timezone=" + java.util.TimeZone.getDefault().getID()
                + ", encoding=" + System.getProperty("file.encoding"));
    }
}
java AppSettings
java -Dapp.env=prod -Dapp.port=9090 -Dapp.debug=true -Duser.timezone=Asia/Kolkata AppSettings
env=dev, port=8080, debug=false
timezone=Asia/Calcutta, encoding=UTF-8
env=prod, port=9090, debug=true
timezone=Asia/Kolkata, encoding=UTF-8
MethodReadsReturns when missing
System.getProperty("k", "def")Any property as StringThe default
Integer.getInteger("k", 8080)A property parsed as intThe default
Boolean.getBoolean("k")true only if the value is "true"false

How it works:

  • Without -D, the program uses its defaults. With -D, the same compiled class behaves differently, so one build serves every environment.
  • Some properties change JDK behavior directly. -Duser.timezone sets the default time zone (the first run shows the machine's own zone), and -Dfile.encoding sets the default charset (UTF-8 by default since JDK 18).
  • Boolean.getBoolean reads a system property, not a string. It is a common source of confusion with Boolean.parseBoolean.

Keep JVM Options in an Argument File

Long command lines are hard to read and easy to break. An argument file holds one or more options per line, and you pass it with @.

# jvm.options
-Xms256m
-Xmx256m
-XX:+UseG1GC
-XX:+ExitOnOutOfMemoryError
-Dapp.env=prod

This program prints the options the JVM actually received:

import java.lang.management.ManagementFactory;

public class ShowJvmArgs {
    public static void main(String[] args) {
        System.out.println("JVM arguments:");
        for (String arg : ManagementFactory.getRuntimeMXBean().getInputArguments()) {
            System.out.println("  " + arg);
        }
        String gcNames = ManagementFactory.getGarbageCollectorMXBeans().stream()
                .map(gc -> gc.getName()).toList().toString();
        System.out.println("Collectors: " + gcNames);
        System.out.println("Max heap: " + Runtime.getRuntime().maxMemory() / (1024 * 1024) + " MB");
    }
}
java @jvm.options ShowJvmArgs
JVM arguments:
  -Xms256m
  -Xmx256m
  -XX:+UseG1GC
  -XX:+ExitOnOutOfMemoryError
  -Dapp.env=prod
Collectors: [G1 Young Generation, G1 Concurrent GC, G1 Old Generation]
Max heap: 256 MB

How it works:

  • Lines starting with # are comments. Each option is read as if it were typed on the command line.
  • getInputArguments() returns the JVM options (not your program arguments). Logging it at startup records exactly how each server was configured.
  • The collector names confirm G1 is active, which is useful when the JVM could have chosen a different one on a small machine.

Set JVM Options With Environment Variables

When you cannot change the command (for example, a script or image you do not own), use an environment variable.

JDK_JAVA_OPTIONS="-Xmx300m" java ShowJvmArgs
NOTE: Picked up JDK_JAVA_OPTIONS: -Xmx300m
JVM arguments:
  -Xmx300m
Collectors: [G1 Young Generation, G1 Concurrent GC, G1 Old Generation]
Max heap: 300 MB
VariableRead byTypical use
JDK_JAVA_OPTIONSOnly the java launcher (JDK 9+)Add options to every java command
JAVA_TOOL_OPTIONSEvery JVM, including javac, jshell and agentsCorporate proxies, trust stores, agents
JAVA_OPTSNothing in the JDK itselfA convention used by scripts such as Tomcat's catalina.sh

How it works:

  • The JVM prints a NOTE or Picked up ... line so you can see that hidden options were applied.
  • Options in JDK_JAVA_OPTIONS come before the command-line options, so the command line still wins if both set the same flag.

Real-World Example: Production JVM Options for CourseServer

This options file is the one referenced by the systemd unit in Java Production Setup. It is tuned for a 2 CPU, 2 GB server running a single web application.

# /etc/courseserver/jvm.options  —  CourseServer, 2 GB VM, JDK 21

# --- memory: fixed 1 GB heap, leaves ~1 GB for metaspace, threads, OS ---
-Xms1g
-Xmx1g
-XX:MaxMetaspaceSize=256m
-Xss512k

# --- garbage collector: G1, aim for pauses under 100 ms ---
-XX:+UseG1GC
-XX:MaxGCPauseMillis=100

# --- failures: dump the heap, then exit so systemd restarts us ---
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/var/lib/courseserver/dumps
-XX:+ExitOnOutOfMemoryError
-XX:ErrorFile=/var/log/courseserver/hs_err_pid%p.log

# --- logging: rotating GC log ---
-Xlog:gc*:file=/var/log/courseserver/gc.log:time,uptime,level,tags:filecount=5,filesize=10m

# --- application defaults ---
-Duser.timezone=UTC
-Dfile.encoding=UTF-8
-Dapp.env=prod

Verify the file before deploying it:

java @/etc/courseserver/jvm.options -XX:+PrintFlagsFinal -version \
  | grep -E ' (MaxHeapSize|InitialHeapSize|MaxMetaspaceSize|MaxGCPauseMillis|ThreadStackSize|UseG1GC|ExitOnOutOfMemoryError) '
     bool ExitOnOutOfMemoryError                   = true                                      {product} {command line}
   size_t InitialHeapSize                          = 1073741824                                {product} {command line}
    uintx MaxGCPauseMillis                         = 100                                       {product} {command line}
   size_t MaxHeapSize                              = 1073741824                                {product} {command line}
   size_t MaxMetaspaceSize                         = 268435456                                 {product} {command line}
     intx ThreadStackSize                          = 512                                    {pd product} {command line}
     bool UseG1GC                                  = true                                      {product} {command line}

How it works:

  1. Fixed heap. -Xms1g -Xmx1g reserves the full heap at startup. Memory use stays flat, and you find out at boot, not at peak traffic, if the server is too small.
  2. Room outside the heap. -XX:MaxMetaspaceSize=256m caps class metadata, and -Xss512k halves each thread stack. Together they keep total RAM use well under 2 GB.
  3. Pause goal. -XX:MaxGCPauseMillis=100 asks G1 to keep pauses near 100 ms instead of the default 200 ms, which suits an HTTP API. G1 treats it as a target, not a guarantee.
  4. Evidence on failure. A heap dump, a crash log (%p becomes the process ID) and the GC log are all written to known folders before the JVM exits with code 3.
  5. Checked before use. Every value shows {command line} in PrintFlagsFinal, proving the file was parsed and nothing was misspelled. A misspelled -XX flag stops the JVM with Unrecognized VM option, so this check catches typos before a deploy.

Once these options are live, Java JVM Monitoring shows how to watch heap, GC and threads on the running server.

0 Comments

Reviewed before they appear

No comments yet.

Java
Java Introduction Java Features Java Syntax Java Comments Java Statements Java Output Java Variables Java Data Types Java Type Casting Java Operators Java Strings Java Numbers Java Math Java Booleans Java User Input Java Conditions Java If Else Java Switch Java While Loop Java For Loop Java Break Java Continue Java Arrays Java Methods Java Parameters Java Return Values Java Scope Java Recursion Install Java Install JDK Java IDEs Java JDK Java JRE Java JVM Java Compiler Java File Compile Java Run Java JShell Basics Java Packages Java OOP Java Classes Java Objects Class Methods Constructors Constructor Overload this Keyword static Keyword final Keyword Encapsulation Inheritance Polymorphism Abstraction Access Modifiers super Keyword Method Overload Method Override Instanceof Operator Nested Classes Inner Classes Anonymous Classes Enums Records Array Basics Array Length Loop Arrays Multidimensional Arrays Array Copy Array Sorting Array Search ArrayList LinkedList HashSet TreeSet HashMap TreeMap Queue Interface Deque Interface Stack Class Iterator List Interface Set Interface Map Interface Collections Class Comparable Comparator Generics Basics Generic Classes Generic Methods Wildcards String Basics String Length String Methods String Concatenation String Compare String Search String Replace String Split String Format StringBuilder StringBuffer Text Blocks Regular Expressions Number Types Integer Class Float Class Double Class BigInteger BigDecimal Math Class Random Numbers Number Format Date Basics LocalDate LocalTime LocalDateTime ZonedDateTime Date Formatting Date Parsing Period Class Duration Class Java Instant Class Java Exception Basics Java try...catch Java Multiple Catch Blocks Java finally Block Java throw Keyword Java throws Keyword Java Checked Exceptions Java Unchecked Exceptions Java Custom Exceptions Java try-with-resources Java Exception Chaining Java File Basics Java Create Files Java Read Files Java Write Files Java Delete Files Java File Paths Java File Class Java BufferedReader Java BufferedWriter Java FileInputStream Java FileOutputStream Java Object Streams Java Directory Handling Java NIO Basics Java Files API Java Input Java Scanner Class Java Console Input Java PrintStream Java InputStream Java OutputStream Java Reader Class Java Writer Class Java Buffered Streams Java Data Streams Java Generics Introduction Java Generic Types Java Generic Methods Java Bounded Types Java Wildcards Java Type Erasure Java Generic Interfaces Java Generic Collections Java Lambda Basics Java Lambda Syntax Java Functional Interfaces Java Method References Java Stream API Java Stream Creation Java Stream Filter Java Stream Map Java Stream Reduce Java Stream Sort Java Stream Collect Java Collectors Class Java Optional Class Java Parallel Streams Java Threads: Thread Basics Create a Thread in Java Java Thread Class Java Runnable Interface Java Thread States Java Thread Sleep Java Thread Join Java Thread Priority Java Synchronization Java Thread Safety Java Race Conditions Java Deadlocks Java Executor Service Java Thread Pools Java Callable Interface Java Future Interface Java CompletableFuture Java Concurrent Collections Java Atomic Classes Java Virtual Threads Java Networking Basics Java URL Class Java URI Class Java HttpClient Java HTTP Requests Java HTTP Responses Java Socket Basics Java ServerSocket Java DatagramSocket Java WebSocket Basics Java JDBC Basics Java JDBC Setup Java Database Connection Java JDBC Connection Interface Java JDBC Statement Java PreparedStatement Java ResultSet Java JDBC CRUD Operations Java JDBC Transactions Java JDBC Batch Update Java Connection Pooling with HikariCP Java JPA Basics: Entities, EntityManager and JPQL Java Hibernate Basics: SessionFactory, Session and HQL Package in Java: Basics Explained with Examples Create Package in Java: Step-by-Step Guide with Examples Import Package in Java: The import Statement Explained Access Control in Java: Packages, Classes and Members JAR File in Java: Create, Run and Inspect JAR Files Java Modules: Introduction to the Java Module System module-info in Java: Every Module Directive Explained Java Module Path: How --module-path Finds Your Modules Java Classpath: How -cp and CLASSPATH Find Your Classes Java Annotations: Basics of @ Metadata in Java Java Built-in Annotations: @Override, @Deprecated and More Java Custom Annotations: Create Your Own @interface Java Annotation Targets: @Target and ElementType Explained Java Reflection API: Inspect and Use Classes at Runtime Java Class Metadata: Names, Modifiers, Hierarchy and Generic Java Dynamic Objects: Create Objects Dynamically With Reflec Java Dynamic Proxy: Intercept Method Calls With Proxy and In Java Security Java Secure Coding Java Password Hashing Java Input Validation Java Cryptography Basics Java KeyStore Basics Java TLS Basics Java SecureRandom Java JUnit Basics Java JUnit Test Methods JUnit Assertions JUnit Test Fixtures JUnit Parameterized Tests Mockito in Java Java Mock Objects Java Integration Testing Java Code Coverage Maven in Java Create a Maven Project in Java Maven Dependencies Maven Plugins Gradle in Java Gradle Build Gradle Dependencies Build Executable JAR in Java Build WAR File in Java HTTP Basics in Java Java Servlet Basics Servlet Lifecycle in Java HttpServletRequest in Java HttpServletResponse in Java JSP in Java JSTL in JSP REST API in Java JSON in Java Java Web Application Spring Framework Basics Spring Boot Tutorial Spring MVC Spring Data JPA Spring Security Spring Boot REST API Jakarta EE Basics Java Deployment JAR Deployment Java WAR Deployment Run Java as a Service Docker Java: Dockerize a Java Application Java Environment Variables and Configuration Java Logging Basics Java Production Setup Java JVM Options Java JVM Monitoring Java Hello World App Java Calculator App Java Number Guess Game Java Student Manager Java Library System Java Bank App Java Todo App Java File Manager Java Quiz App Java REST API Project Java Chat Server Java Employee Manager Java E-commerce API
Ask about this post
AI Ask about this post

Ask questions about Java JVM Options and get answers drawn from it.

Signed-in readers only.