SoFunction
Updated on 2025-04-07

Use startup commands in java

1. Introduction

The importance of Java startup parameters

Java startup parameters have a great impact on the performance and behavior of Java applications. Through these parameters, developers and system administrators can control the memory usage, garbage collection policies, performance optimization and debugging capabilities of Java virtual machines (JVMs). Properly configuring these parameters can help optimize the execution efficiency of the application, reduce the waste of system resources, and improve the response speed and processing capabilities of the application.

When facing different application scenarios, such as high concurrency processing, big data processing or microservice architecture, appropriate startup parameter settings can significantly affect the stability and efficiency of the application. For example, by adjusting the heap memory size and garbage collection strategy, the risk of memory overflow and latency caused by garbage collection can be reduced.

In addition, Java startup parameters can help developers better diagnose and resolve problems during the development and testing phases, such as enabling detailed garbage collection logs to analyze memory problems, or using performance analysis tools to detect bottlenecks in code.

Parameter classification overview

Java startup parameters can be roughly divided into the following categories:

  • Basic memory management parameters: Involves the initialization size, maximum size, and thread stack size of the Java heap.
  • Metaspace management parameters: Manage non-heap memory areas, mainly used to store class metadata.
  • Garbage collection parameters: Controls the selection and behavior of the garbage collector, as well as the output of the garbage collection log.
  • Performance Tuning and Diagnostic Parameters: Includes parameters for performance optimization, such as code cache size and use of compressed pointers, as well as parameters for diagnosis, such as heap dump path and heap dump on memory overflow.
  • Java Agent Parameters: Used to load Java Agents, which are usually used to monitor, analyze, and modify application behavior.
  • System attribute parameters: Set system-level properties, such as file encoding and system ports.
  • Apply execution parameters: Parameters directly related to application execution, such as the specified running Jar file.

Understanding the classification and specific uses of these parameters will help readers more systematically master the configuration methods of Java startup parameters, and be able to flexibly adjust according to actual needs, in order to achieve the best application performance and stability.

2. Basic memory management parameters

In Java applications, memory management is the key to ensuring performance and stability.

Here are several basic memory management parameters that directly affect the memory allocation and use of Java virtual machines (JVMs).

-Xms: Initial heap size

parameter-XmsUsed to set the initial size of heap memory when JVM starts.

This value can help the JVM preallocate memory at startup, reducing the number of memory allocations at runtime, thereby improving performance.

For example, if the application is expected to use more memory, this value can be increased appropriately to reduce the frequency of garbage collection.

Example：

java -Xms512m -jar

This command sets the initial size of the heap memory when JVM starts up to 512MB.

-Xmx: Maximum heap size

parameter-XmxUsed to set the maximum heap memory size that the JVM can use.

This is the maximum memory limit that can be used to store objects during the JVM operation. Exceeding this value may causeOutOfMemoryError。

Setting this parameter can prevent the JVM from using too much system memory and avoid affecting the operation of other programs or systems.

Example：

java -Xmx1024m -jar

This command sets the maximum heap memory of the JVM to 1024MB.

-Xss: Stack size for each thread

parameter-XssDefines the stack size of each thread.

The stack size directly affects the depth of the method that the thread can call (i.e. the depth when the method is called).

Too small settings may cause*Error, setting too large will waste memory, especially when creating applications with a large number of threads.

Example：

java -Xss256k -jar

This command sets the stack size of each thread to 256KB.

By rationally configuring these basic memory management parameters, developers can effectively manage the memory usage of JVM, optimize application performance, and avoid memory overflow and other problems.

3. Metaspace management parameters

Starting from Java 8, Metaspace replaced the original PermGen to store the metadata of the class.

Unlike permanent generations, metaspace uses local memory (i.e. non-heap memory), so management of metaspace is crucial to avoid memory overflows, optimize performance, and ensure class loading efficiency.

The following are two commonly used metaspace management parameters:

-XX:MetaspaceSize: Initial size of metaspace

This parameter is used to set the initial size of the metaspace, that is, the amount of memory allocated to the metaspace when the JVM starts up.

If set properly, the application can avoid frequent memory expansion during the startup phase, thereby improving performance.

The default value depends on the platform, but is usually a relatively small value, and the metaspace may need to be dynamically expanded as the application runtime class loads.

-XX:MaxMetaspaceSize: Maximum metaspace size

This parameter sets the maximum amount of memory that the metaspace can use. Limiting the maximum metaspace size can prevent some types of memory leaks or unlimited class loading from excessive local memory consumption.

If the metaspace reaches this limit, the JVM will trigger garbage collection to clean up class metadata that is no longer in use. If the space is still insufficient after recycling, the JVM will throwOutOfMemoryError。

When configuring these parameters, it needs to be adjusted according to the application's class loading requirements.

For example, large applications or applications that use a large number of dynamically generated classes may require a larger metaspace initial or maximum size. On the contrary, for small applications with relatively fixed class loading, a smaller value may be sufficient. Adjusting these parameters usually requires optimization through monitoring tools and actual operation.

4. Garbage collection parameters

Garbage collection (GC) parameters are a very critical part of Java performance tuning. They can help developers control and optimize the garbage collection process, reduce latency caused by GC, and improve application performance.

Here are some commonly used GC parameters:

  • -Xloggc:<file>: This parameter is used to specify the output file path of the garbage collection log. By outputting GC logs to files, developers can more conveniently perform subsequent analysis of the garbage collection process. For example,-Xloggc:/logs/Output GC logs to the specified pathin the file.
  • -XX:+UseG1GC: This parameter enables the G1 garbage collector, which is a server-oriented collector designed to reduce GC pause time while maintaining good throughput. The G1 collector is especially suitable for multi-core processors and large memory environments, and can efficiently manage heaps.
  • -XX:+PrintGCDetails: This parameter is used to output detailed GC log information. When this option is enabled, the log will contain detailed information about each GC, such as the memory space front and back of each generation, the time spent GC, etc., which is very helpful for analyzing and tuning GC performance.
  • -XX:NewRatio: This parameter is used to set the memory ratio between the Old Generation and the Young Generation. For example,-XX:NewRatio=2It means that the old age is twice the size of the new generation. By adjusting this scale, memory allocation and GC performance can be optimized based on the application's object survival characteristics.
  • -XX:SurvivorRatio: Set the ratio of Eden area to two Survivor areas in the new generation. By default, this ratio is usually set to 8, i.e. the ratio of Eden area to each Survivor area is 8:1. Adjusting this parameter can affect the promotion time of short-term surviving objects, thereby affecting the efficiency of GC.

By configuring these parameters reasonably, developers can adjust the JVM's garbage collection strategy for specific application needs and operation environments, thereby optimizing application performance and response speed.

5. Performance Tuning and Diagnostic Parameters

Performance tuning and diagnostic parameters are indispensable tools in Java application management. They not only help developers optimize application performance, but also provide the necessary information when problems arise to diagnose and solve problems.

Here are some commonly used performance tuning and diagnostic related parameters:

-XX:+HeapDumpOnOutOfMemoryError

When the Java virtual machine is thrownOutOfMemoryErrorIn the event of an exception, this parameter will instruct the JVM to automatically generate the heap dump file.

This is very helpful for subsequent analysis of memory usage and locating the causes of memory leaks.

-XX:HeapDumpPath

This parameter is used to specify the storage path of the heap dump file.

If this parameter is not set, heap dump files are usually stored in the JVM startup directory, which may cause insufficient storage space or management inconvenience.

-XX:+UseCompressedOops

Enable Compressed Ordinary Object Pointers, an optimization technique that reduces the memory footprint of the Java heap without significantly increasing the retrieval time.

This is usually used on 64-bit JVMs, especially when the heap memory is not very large.

-XX:InitialCodeCacheSize and -XX:ReservedCodeCacheSize

These two parameters are used to control the initial size and maximum reserved size of the code cache.

Code cache is an area that stores local machine code dynamically generated by the JVM. Appropriate adjustment of these parameters can improve the execution efficiency and response speed of the JVM.

  • -XX:InitialCodeCacheSize: Set the initial size of the code cache, this value can be adjusted according to the application needs.
  • -XX:ReservedCodeCacheSize: Set the maximum reserved size of the code cache to ensure that there is enough space to store the code compiled by the JIT compiler.

By rationally configuring these parameters, developers can effectively manage and optimize the running environment of Java applications, improve application performance and reduce runtime problems.

6. Java Agent parameters

Java Agent provides a powerful mechanism that allows developers to modify application behavior at runtime, often used for performance monitoring, auditing, and various other runtime analysis tasks.

These agents can be loaded on the start of the Java virtual machine (JVM) or attached to the already running JVM at runtime.

  • -javaagent:<jarpath>[=<options>]: This is the most commonly used parameter to load a Java Agent.
  • Here<jarpath>Point to a JAR file containing the Agent class and the Manifest file.
  • The manifest file must contain aAgent-ClassAttributes, indicate which class implements the Agent interface.
  • Optional<options>Provides a way to pass string format parameters to the Agent that can be used when the Agent is initialized.

For example, if you have an Agent for a performance monitoring tool, you might use the following command to start your Java application:

java -javaagent:/path/to/=options -jar

In this example,/path/to/is the JAR file path of the Agent.optionsis the initialization parameters passed to the Agent, and these parameters will be determined according to the specific Agent implementation.

Using Java Agent is a very flexible way to extend the functionality of an application without modifying the application's own code. This makes it a valuable tool for problem diagnosis and performance optimization in production environments.

7. System attribute parameters

System attribute parameters allow users to set or modify JVM and application-level configurations when starting Java applications.

This method is very flexible and can directly pass parameters through the command line, which affects the behavior or environment settings of the application.

Here are some common system property parameters examples:

-

This parameter is used to set the default character set used by the JVM. For example, if your application needs to handle specific character encodings, you can specify this parameter, such as-=UTF-8Make sure that the application uses UTF-8 encoding when processing strings.

- and -

These two parameter examples show how to specify custom configuration properties for the application. Typically, such parameters are used to specify the network port of the application service, and are used for different services or management interfaces respectively.

For example,-=8080and-=9090It can be used to set up application service ports and management ports respectively.

-

This is another common system property that sets the port on which the service runs. This parameter is commonly used in applications based on frameworks such as Spring Boot. The service port can be modified directly through the command line, such as-=8000, so that the application will run on port 8000.

The flexibility of system attribute parameters makes them an important tool for tuning and configuring Java application environment. Through these parameters, developers can adjust the behavior of applications according to the needs of the deployment environment without modifying the code.

8. Apply execution parameters

Application execution parameters are parameters that directly affect the way Java applications are started. These parameters are usually used to specify how to run a Java program, including which jar file to run or specify the main class, etc.

-jar

  • This parameter is used to specify the jar file to be run, it tells the JVM to find it directly from the specified jar packageMain-ClassList properties and start the classmainmethod.
  • use-jarWhen arguments are made, the JVM ignores any main class specified on the command line.

Example:

java -jar

In this example,It is an executable jar file that contains all necessary resources and dependencies. The JVM will start the application based on the manifest file in the jar file.

use-jarWhen using parameters, you can also combine other JVM parameters to optimize performance, manage memory, or configure system properties, etc.

For example, you can set the maximum heap size and system properties while starting the jar application:

java -Xmx1024m -=UTF-8 -jar

This command sets the maximum heap memory to 1024MB, and specifies the character set to UTF-8, and then starts。

Through the combination of these parameters, developers can flexibly control the running environment and behavior of Java applications to adapt to different runtime requirements and deployment environments.

9. Conclusion

In this article, we discuss in detail several commonly used parameters in Java startup commands, including memory management, metaspace management, garbage collection logs, Java Agents, system properties, and application execution parameters.

Each type of parameters has its own unique functions and configuration methods. Using these parameters correctly can significantly improve the performance, manageability and debugability of Java applications.

Best Practices

  1. Memory and performance optimization: Rational configuration-Xmsand-XmxParameters to optimize the startup and maximum memory of the JVM. Avoid frequent garbage collection caused by too small memory, and also avoid waste of resources caused by too large memory.
  2. Garbage recycling strategy selection: Choose the appropriate garbage collector according to the needs of the application. For example, G1 is more suitable for applications that require low pause time.
  3. Monitoring with Java Agent: Rationally use Java Agent for application performance monitoring and problem diagnosis, but pay attention to its potential impact on performance.
  4. Flexible application of system attributes: By passing the configuration through the system attribute parameters, the configurability of the application can be improved and it can be easier to adapt to different deployment environments.
  5. Identify application execution parameters:use-jarThe parameters such as the application clearly specify the startup method and dependency of the application to ensure the correct operation of the application.

Call readers to test and optimize

Theory and practice are always complementary. We encourage readers to apply these parameters not only in the development environment, but more importantly in the production environment to conduct actual testing and optimization. The actual performance of each application may vary depending on the hardware, network, and other external conditions in which it is located.

  • test: After changing any parameters, conduct comprehensive testing, including performance and stability testing, ensuring that new configurations do not introduce unforeseen problems.
  • monitor: Use monitoring tools to continuously observe the performance of applications in production environments, especially memory usage and garbage collection behavior.
  • Feedback loop: Adjust the parameter configuration based on monitoring results and user feedback to optimize application performance.

Through continuous testing, monitoring and optimization, we can gradually understand the specific impact of various parameters on application performance, so that Java applications can achieve the best operating state.

Practical examples

java
-Xms4096m
-Xmx8192m
-XX:MetaspaceSize=128m
-XX:MaxMetaspaceSize=512m
-Xloggc:/home/my-service/tsf_apm/monitor/jvm-metrics/
-javaagent:/home/my-service/TencentCloudJvmMonitor-1.1.=hascontroller=true
-=utf-8
-=8081
-=9081
-=80
-jar

The above is personal experience. I hope you can give you a reference and I hope you can support me more.