Shulou(Shulou.com)06/02 Report--

This article mainly introduces "what are the commonly used java virtual machine parameters". In the daily operation, I believe that many people have doubts about the commonly used java virtual machine parameters. The editor consulted all kinds of materials and sorted out simple and easy-to-use operation methods. I hope it will be helpful for you to answer the doubts about "what are the commonly used java virtual machine parameters?" Next, please follow the editor to study!

1. Master tracking debugging parameters 1.1 track garbage collection 1 print garbage collection log:-XX:+PrintGC (- Xlog:gc is recommended in jdk9 and jdk10)

One of the simplest GC parameters is-XX:+PrintGC (- Xlog:gc is recommended in jdk9 and jdk10). After starting jvm with this parameter, the log will be printed whenever a GC is encountered.

[GC 4893K-> 377K (15872K), 0.0006926 secs]

A row of records indicates a GC, which shows that before GC, the heap space usage is about 4MB, after GC, the heap space usage is 377KB, and the current sum of heap space is about 16MB (15872K). Finally, the time spent on this GC is shown.

Jdk9 and jdk10 use G1 as the garbage collector by default, and use the parameter-Xlog:gc to print GC logs, as shown in the following figure:

[0.012s] [info] [gc] Using G1 [0.107s] [info] [gc] GC (0) Pause Full (System.gc ()) 16m-> 7m (34m) 23.511ms

The log shows that there is a total of one GC. Before GC, the heap space usage is 16MB, after GC, the heap space usage is 7MB, and the current total heap space is 34MB. Finally, the time spent on this GC is shown, which is 23.511ms.

two。 Print garbage collection log details:-XX+PrintGCDetails (recommended in jdk9 and jdk10-Xlog:gc*)

If you need more detailed information, you can use the-XX:+PrintGCDetails (recommended in jdk9, jdk10) parameter. This parameter causes the virtual machine to print details of the heap before exiting, which describes the usage of each interval of the current heap.

3. Output information about the heap before and after GC:-XX:+PrintHeapAtGc (since jdk9, this parameter has been deleted)

If you need more comprehensive heap information, you can also use-XX:+PrintHeapAtGc (for compatibility, this parameter has been removed from jdk9, and you can use Visual VM to view heap information). It prints the heap information before and after each GC, just like the final output of-XX+PrintGCDetails.

4. Focus on the application quiesce caused by GC

Because GC causes the application to pause, you also need to pay special attention to the execution time and pause time of the application. Use the parameter-XX:+PrintGCApplicationConcurrentTime to print the execution time of the application, and the parameter-XX:+PrintGCApplicationStoppedTime to print the pause time of the application due to GC.

5. Track soft references, weak references, virtual references, and Finallize queues within the system

If you want to track soft references, weak references, virtual references, and Finallize queues within the system, you can turn on the-XX:+PrintReferenceGC (this parameter has been removed since jdk9 for compatibility, and you can use Visual VM to view heap information).

6. Specify gc log location

By default, GC logs are output in the console, which makes it difficult to analyze and locate problems later. So the virtual machine allows GC logs to be output as files, which can be specified with the parameter-Xloggc.

For example, if you start the virtual machine with the parameter-Xloggc:log/gc.log (recommended for jdk9, jdk10), you can record all GC logs in the gc.log file under the log folder of the current directory.

1.2 tracking of class load / unload

Java programs can not run without class loading. In order to better understand how the program is executed, it is sometimes necessary to know which classes are loaded by the system.

Track the loading and unloading of classes: you can use the parameter-verbose:class to track the loading and unloading of classes.

Tracking class loading separately: you can track class loading separately using the parameter-XX:+TraceClassLoading (- Xlog:class+load=info is recommended in jdk9 and jdk10, which has the same effect as the parameter-XX:+TraceClassLoading in jdk8).

Track the unloading of classes separately: you can track the unloading of classes using the parameter-XX:+TraceClassUnloading (- Xlog:class+unload=info is recommended in jdk9 and jdk10, which is the same as the parameter-XX:+TraceClassUnloading in jdk8).

-XX:+PrintClassHistogram: this parameter indicates that the column information of the class instance is printed when Ctrl-Break is encountered. It has the same function as jmap-histo.

1.3 View system parameters

As the current java virtual machine supports a large number of configurable parameters, different parameters may have a great impact on the execution effect of the system, so it is necessary to clarify the actual running parameters of the current system. Virtual machines provide some means to help developers obtain these parameters.

-XX:PrintVMOptions: you can print command-line explicit parameters received by the virtual machine while the program is running.

-XX:PrintCommandLineFlags: the display and implicit parameters that can be transferred to the virtual machine. The implicit parameters may not be given directly from the command line. They may be set by themselves when the virtual machine starts.

-XX:+PrintFlagsFinal: prints the values of all system parameters. When this parameter is enabled, the virtual machine may produce more than 500 lines of output, one configuration parameter for each behavior and its current value.

two。 Configuration parameter 2.1 initial heap and maximum heap

The initial heap and the maximum heap are specified using-Xms and-Xmx, respectively, for example, the initial heap size is 5MB, the maximum heap size is 20MB:-Xms5m, and-Xmx20m. In actual production, in order to reduce the number of garbage collection when the program is running, the initial heap-Xms and the maximum heap-Xmx are set to equal directly.

2.2 Cenozoic configuration

The parameter-Xmn can be used to set the size of the new generation, and set a larger new generation to reduce the size of the old age. This parameter has a great impact on system performance and GC behavior. * * the size of the Cenozoic generation is generally set from 1 to 4 of the entire heap space.

The parameter-XX:SurvivorRatio is used to set the ratio of the Eden zone to the from/to zone in the Cenozoic era, which means as follows:

-XX:SurvivorRatio = eden/form = eden/to

Example:

Public class Demo02 {public static void main (String [] args) {byte [] b = null; for (int I = 0; I

< 10; i++) { b = new byte[2 * 1024 * 1024]; } }}(1) 使用参数 -Xmx40m -Xms40m -Xmn2m -XX:SurvivorRatio=2 -XX:+PrintGCDetails 运行[GC (Allocation Failure) [PSYoungGen: 1024K->

432K (1536K)] 1024K-> 432K (40448K), 0.0015289 secs] [Times: user=0.00 sys=0.00, real=0.00 secs] Heap PSYoungGen total 1536K, used 885K [0x00000007bfe00000, 0x00000007c0000000, 0x00000007c0000000) eden space 1024K, 44% used [0x00000007bfe0000000x00007bfe716b0re0x00000007bff0000000) from space 512K, 84% used [0x00000007bff00000art 0x0000000007bff80000) to space 512K, used [0x00000007ff80000000000007bff800000000007bff80000000000007c0000000000007c00000000000000007c000000000000007c0000000000007c00000000000000007c00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007bff7bff00000000000000007bff7bff00000bff7bff7bff00000x00007bff7bfe00000x00007bff7bfe00000x00007bff7bfe00000x00007bff716bfe000x00000007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00000x00007bff00 Capacity 388K, committed 512K, reserved 1048576K

The ratio of eden region to from region is 2:1, so the eden region is 1024kb, the total available size is 1024kb+512kb = 1536kb, and the Cenozoic total size is 1024kb+512kb+512kb=2048kb=2mb.

Because the eden area cannot hold the array of 2MB allocated in any program, a new generation of gc is triggered, and the eden area is partially recycled. At the same time, this small Cenozoic generation cannot reserve space for 2MB arrays, so all arrays are allocated in the old age, which eventually takes up 20480K space.

(2) use the parameter-Xmx40m-Xms40m-Xmn14m-XX:SurvivorRatio=2-XX:+PrintGCDetails to run [GC (Allocation Failure) [PSYoungGen: 5477K-> 2560K (10752K)] 5477K-> 2568K (37376K), 0.0016892 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [PSYoungGen: 8915K-> 2592K (10752K)] 8923K-> 2600K (376K), 0.0015561 secs] [Times: user=0.00 sys=0.00 Real=0.00 secs] [GC (Allocation Failure) [PSYoungGen: 9050K-> 2544K (10752K)] 9058K-> 2552K (37376K), 0.0009707 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] Heap PSYoungGen total 10752K, used 6871K [0x00000007bf200000, 0x00000007c0000000, 0x00000007c0000000) eden space 7168K, 60% used [0x00000007bf200000prime0x00000007bf639d28mer 0x0000000007bf900000) from space 3584K, 70% used [0x00000007bf900000m0x00007bf7c020people 0x00000007bfc80000) to space 3584K, 0% used [0x00000007bfc00000000007bfc00000x00007bfc000000007c00000000007bfc000000007bfc00000000007bfc00000000007bfc00000x00007bfc00000000007bfc00000x00007bfc000000007bfc00000x00007bfc000000007bfc000000007bfc000000007bfc0000007bfc8000x0000007bfc000000007bfc8000x00007bfc000000007bfc8000x0000007bfc000000007bfc000000007bfc8000x0000007bfc000000007bfc0000007bfc0000007bfc0000007bfc000x00007bfc0000007bfc000x00007bfc000000007bfc00 0% used [0x00000007bd800000Jr0x00000007bd802000J0x00000007bf200000) Metaspace used 2970K, capacity 4496K, committed 4864K, reserved 1056768K class space used 328K, capacity 388K, committed 512K, reserved 1048576K

This time, the Cenozoic generation is expanded to 14MB (7168k+3584K+3584k=14336K). Under this parameter, all arrays are allocated to the eden area because there is enough space in the EDN area. However, the eden area is not enough to reserve space for 10MB, so there are three times of Cenozoic gc during the running of the program. Due to each application space, but also abandoned the last application space (the last application memory lost introduction), so in the new generation of gc, effectively reclaim these invalid memory. The end result is that all memory allocation is carried out in the new generation, which ensures that the new generation has enough space through gc, while the old age does not reserve any space for these arrays, but in the process of gc, some of the new generation objects are promoted to the old age.

(3) use the parameter-Xmx40m-Xms40m-Xmn30m-XX:SurvivorRatio=8-XX:+PrintGCDetails to run Heap PSYoungGen total 27648K, used 23437K [0x00000007be200000, 0x00000007c0000000, 0x00000007c0000000) eden space 24576K, 95% used [0x00000007bf8e3510meme0x0000000007bf00000) from space 3072K, 0% used [0x00000007bfd00000m0x00007bfd000000x00007c000000000) to space 3072K, 0% used [0x0000000007bfa000000x00000007bfa00000re0x00000007bfd0000000) ParOldGen total 10240K, used 0K [0x00000007bfd80000000007be0000x00000007be200000) object space 100K, 0% used [0x00000007bfd00000000bfa000000x000007bfa000000x00007bfa000000640030K Metaspace used)

In this execution, because the new generation uses 30MB space, where eden accounts for 24MB (30MB / 10 * 8), which fully satisfies the allocation of the 10MB array, all allocation activities are carried out directly in the eden area, and no GC behavior is triggered. As a result, the utilization rate of from/to and the old age is 0.

Thus it can be seen that different heap distribution will have a certain impact on the system. In practical work, reasonable settings should be made according to the characteristics of the system, and the basic strategy is to reserve objects in the new generation as much as possible to reduce the number of gc in the old era.

(4) use the parameter-Xmx40m-Xms40m-XX:NewRatio=2-XX:+PrintGCDetails

In addition to using the parameter-Xmn to specify the absolute size of the new generation, you can also use the parameter-XX:NewRatio to set the ratio of the new generation to the old generation, as shown below:

-XX:NewRatio= Old Age / New Generation

In this example, the ratio of the old generation to the new generation is set at 2:1. The running results are as follows:

[GC (Allocation Failure) [PSYoungGen: 10075K-> 496K (11776K)] 10075K-> 2552K (39424K), 0.0019760 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] [GC (Allocation Failure) [PSYoungGen: 8989K-> 560K (11776K)] 11045K-> 4672K (39424K), 0.0015192 secs] [Times: user=0.01 sys=0.00, real=0.00 secs] Heap PSYoungGen total 11776K, used 5144K [0x00000007bf300000, 0x00000007c0000000, 0x00000007c0000000) eden space 1024K, 44% used [0x00000007bf300000 0x00000007bf77a08book 0x00000007bfd00000) from space 1536K 36% used [0x00000007bff0c010 used 0x00000007bfd00000) to space 1536K, 0% used [0x00000007bfd00000m0x00000007bfd00000000000007bfe80000) ParOldGen total 27648K, used 4112K [0x00000007bd800000, 0x00000007bf300000, 0x00000007bf300000) object space 27648K, 14% used [0x00000007bd800000 0x00000007bdc04020) Metaspace used 3044K, capacity 4496K, committed 4864K, reserved 1056768K class space used 333K, capacity 388K, committed 512K, reserved 10576K

At this time, the size of the heap is 40MB, and the ratio of the Cenozoic to the old is 1:2, so the size of the Cenozoic is 40 * (1max 3) = 14MB (where eden is about 14MB * (8x10) = 11.2MB from eden to size 14 * (1x10) = 1.4MB), and the old age is about 26MB. Because in the new generation GC, the from/to space is not enough to hold any 2MB array, which affects the normal recycling of the new generation, so the old age space guarantee is needed in the new generation recycling. This brings two 2MB arrays into the old age (in the Cenozoic gc, there are still 1MB arrays that survive and are supposed to enter the from/to region, while the from/to area has only 1.4MB, which is not enough to accommodate).

2.3 Heap memory overflow

During the running of the java program, if there is not enough heap space, it is possible to throw a memory overflow, referred to as OOM:

Public class Demo03 {public static void main (String [] args) {Vector vector = new Vector (); for (int I = 0; I < 25; iTunes +) {vector.add (new byte [1x 1024 1024]);}

Start with the parameter-Xmx20m-Xms20m-XX:+HeapDumpOnOutOfMemoryError-XX:HeapDumpPath=./dump.log, and the result is as follows:

Java.lang.OutOfMemoryError: Java heap spaceDumping heap to. / dump.log... Heap dump file created [19887142 bytes in 0.015 secs] Exception in thread "main" java.lang.OutOfMemoryError: Java heap space at jvm.chapter03.Demo03.main (Demo03.java:16)

As you can see, the virtual machine exports the current stack information and saves it to the dump.out file.

In addition to exporting heap information when OOM occurs, the virtual machine also allows a script file to be executed when an error occurs. This file can be used for self-rescue, alarm or notification of crashing programs, and can also help developers get more system information, such as complete thread saving.

3. Parameter configuration of non-heap memory 3.1 method area configuration

In versions such as jdk 1.6 and jdk 1.7, the permanent zone size can be configured using-XX:PermSize and-XX:MaxPermSize. Where-XX:PermSize represents the initial permanent zone size and-XX:MaxPermSize represents the maximum permanent zone size.

Starting with jdk1.8, the permanent zone is completely removed, and a new metadata area is used to hold the class's metadata. By default, the metadata zone is only limited by the memory available to the system, but you can still use the parameter-MaxMetaspaceSize to specify the maximum available value for the permanent zone.

3.2 Direct memory configuration

After NIO is widely used, the use of direct memory becomes very common, direct memory skips the Java heap, and Java programs can directly access the native heap space. Therefore, the access speed of memory space is accelerated to some extent.

The maximum direct memory can be set using the parameter-XX:MaxDirectMemorySize. If not set, the default value is the maximum heap space, that is, the value of-Xmx. When direct memory usage reaches-XX:MaxDirectMemorySize, garbage collection will be triggered. If garbage collection does not effectively free up enough space, direct memory overflow will still cause OOM of the system.

Direct memory is accessed faster than heap memory; when requesting space, heap memory is much faster than direct memory. Therefore, direct memory is suitable for occasions with less applications and frequent visits. If you need to apply for memory space frequently, it is not appropriate to use direct memory.

3. Client and Server: the working mode of virtual machines

At present, the java virtual machine supports both Client and Server operation modes. Use the parameter-client to specify the use of Client mode, and use the parameter-server to specify the use of Server mode. By default, the virtual machine automatically selects the operation mode according to the current computer system environment. Use the-version parameter to view the current mode:

Java version "1.8.0mm 201" Java (TM) SE Runtime Environment (build 1.8.0_201-b09) Java HotSpot (TM) 64-Bit Server VM (build 25.201-b09, mixed mode)

Server mode starts more slowly than client mode because server mode tries to collect more system performance information and uses more complex algorithms to optimize the program. Therefore, when the system is fully started and enters a stable period, the execution speed of server mode is much faster than that of client mode ``. For long-running systems, it is more suitable for server mode, but for user interface programs, the running time is not long, and the pursuit of startup speed is more suitable for client mode.

The various parameters of a virtual machine in server mode and client mode may be very different. You can use-XX:+PrintFlagsFinal to view the default values of the parameters. Take CompileThreshold and MaxHeapSize as an example. The example is as follows:

For client mode:

$java-XX:+PrintFlagsFinal-client-version | grep-E 'CompileThreshold | MaxHeapSize' intx CompileThreshold = 10000 {pd product} uintx MaxHeapSize: = 4294967296 {product} intx Tier2CompileThreshold = 0 {product} intx Tier3CompileThreshold = 2000 {product} intx Tier4CompileThreshold = 15000 {product} java version "1.8.02.201" Java (TM) SE Runtime Environment (build 1.8.0_201-b09) Java HotSpot (TM) 64-Bit Server VM (build 25.201-b09) Mixed mode)

For server mode:

$java-XX:+PrintFlagsFinal-server-version | grep-E 'CompileThreshold | MaxHeapSize' intx CompileThreshold = 10000 {pd product} uintx MaxHeapSize: = 4294967296 {product} intx Tier2CompileThreshold = 0 {product} intx Tier3CompileThreshold = 2000 {product} intx Tier4CompileThreshold = 15000 {product} java version "1.8.02.201" Java (TM) SE Runtime Environment (build 1.8.0_201-b09) Java HotSpot (TM) 64-Bit Server VM (build 25.201-b09) Mixed mode) so far On the "commonly used java virtual machine parameters what are the end of the study, I hope to be able to solve your doubts." The collocation of theory and practice can better help you learn, go and try it! If you want to continue to learn more related knowledge, please continue to follow the website, the editor will continue to work hard to bring you more practical articles!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.