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

Today, I will talk to you about how to reasonably plan a JVM performance tuning. Many people may not know much about it. In order to let everyone know more, Xiaobian summarizes the following contents for everyone. I hope you can gain something according to this article.

Abstract: JVM performance tuning involves all aspects of the trade-off, often one hair and the whole body, need to consider all aspects of the impact, then how to conduct an elegant tuning, improve application performance?

JVM performance tuning involves all aspects of trade-offs, often one hair and the whole body, need to consider all aspects of the impact. But there are some basic theories and principles that understanding and following will make your task of tuning performance easier. In order to better understand the content presented in this article. You need to already know and follow the following:

1. Understand jvm garbage collector

2. Common tools for jvm performance monitoring have been understood.

3. Be able to read GC logs

4, convinced not to tune for tuning, jvm tuning can not solve all performance problems

These contents have been introduced in the previous two articles. If you don't understand them, you can click on the above links to review them. If you don't understand them, it is not recommended to read this article.

I. Levels of performance tuning

In order to improve system performance, we need to optimize various aspects and levels of the system. Here are a few levels that need to be optimized.

From the above we can see that in addition to jvm tuning, there are several other levels to be dealt with, so tuning for the system is not only jvm tuning, but the overall system tuning is needed to improve the system performance. This article is only for jvm tuning to explain, other aspects, later introduced.

Before jvm tuning, we assume that architectural tuning and code tuning for the project have already been done or are optimal for the current project. These two are the foundation of jvm tuning, and architecture tuning has the greatest impact on the system. We can't expect a system architecture to be flawed or code level optimization to have no exhaustive application. It is impossible to achieve a qualitative leap through jvm tuning.

In addition, before tuning, you must have a clear performance optimization goal and then find its performance bottleneck. After optimization for bottlenecks, it is also necessary to stress and benchmark the application, and use various monitoring and statistical tools to confirm whether the tuned application has reached the relevant goals.

II. JVM tuning process

The ultimate goal of tuning is to get the application to carry more throughput with minimal hardware consumption. Jvm tuning is no exception. Jvm tuning is mainly aimed at optimizing the collection performance of garbage collectors, so that applications running on virtual machines can use less memory and delay to obtain greater throughput. Of course, the least is the best choice here, not the less the better.

1. Definition of performance

To find and evaluate performance bottlenecks, we first need to know the performance definition. For jvm tuning, we need to know the following three definition attributes as the basis for evaluation:

Throughput: An important metric is the maximum performance that a garbage collector can support an application, regardless of latency or memory consumption caused by garbage collection.

Latency: This is measured by reducing or eliminating the pause caused by garbage collection to avoid jitter in application runtime.

Memory footprint: The amount of memory required for the garbage collector to run smoothly.

Among these three attributes, the performance improvement of any one of them is almost always at the cost of the performance loss of the other one or two attributes. The performance of a specific attribute or two attributes is more important to the application and should be determined based on the business requirements of the application.

2. Performance optimization principles

During tuning, we should keep the following three principles in mind to help us more easily tune garbage collection to meet application performance requirements.

Minor GC collection principle: each minor GC should collect as many garbage objects as possible. To reduce the frequency of Full GC for applications.

GC memory maximization principle: When dealing with throughput and latency issues, the more memory the garbage processor can use, the better the garbage collection effect, and the smoother the application.

GC tuning 3 out of 2 principle: In the performance attributes, throughput, delay, memory occupation, we can only choose two of them for tuning, not all three.

3. Performance tuning process

The above is the basic process of jvm tuning for the application. We can see that jvm tuning is a process of multiple iterations based on the performance test results to continuously optimize the configuration. Each of the preceding steps may go through multiple iterations before each system requirement metric is met. Sometimes in order to achieve a certain aspect of the index, it may be necessary to make multiple adjustments to the previous parameters, and then need to re-test all the previous steps.

In addition, tuning generally starts from meeting the memory usage requirements of the program, followed by the time delay requirements, and finally the throughput requirements. It is necessary to continuously optimize based on this step. Each step is the basis for the next step, and cannot be reversed. Below we explain each step in detail.

In terms of JVM operation mode, we directly choose server mode, which is also the officially recommended mode after jdk 1.6.

In terms of garbage collector, we directly adopt the default parallel collector in jdk 1.6 -1.8 (parallelGC for new generation and parallelOldGC for old generation).

Third, determine the memory occupation

Before determining memory footprint, we need to know two things:

Application runtime

jvm memory allocation

1. Operation phase

The run-time phase of the application, I can divide it into the following three phases:

1. Initialization phase: jvm loads the application and initializes the main modules and data of the application.

2, stable stage: the application runs most of the time at this time, after experiencing the pressure test, the performance parameters are stable. Core functions are executed and pre-warmed by jit compilation.

Summary stage: The final summary stage, some benchmark tests, generate a response policy report. We can ignore this phase.

To determine the memory footprint and the size of active data, we should determine it at the stable stage of the program, not at the beginning of the project. How to determine it, we first look at the following jvm memory allocation.

2. jvm memory allocation & parameters

The main space in the jvm heap is composed of the above Cenozoic, Old Cenozoic and Permanent Generation, and the whole heap size = Cenozoic size + Old Cenozoic size + Permanent generation size. The specific object promotion method, here is not too much introduction, we look at some jvm command parameters, the heap size specification. If not specified with the following parameters, the virtual machine automatically selects appropriate values and adjusts automatically based on system overhead.

generational

parameters

described

heap size

-Xms

Initial heap size, default is 1/64 of physical memory (

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.