JVM Tuning Summary-XMS-XMX-XMN-XSS

2. Heap Size Settings
   The maximum heap size in the JVM has three limitations: the data Model (32-BT or 64-bit) of the associated operating system, the system's available virtual memory limits, and the available physical memory limits for the system. Under the 32-bit system, the 1.5g~2g;64 is generally limited to memory unrestricted for the operating system. I test under Windows Server 2003 System, 3.5G physical memory, JDK5.0, Max can be set to 1478m.
   Typical settings:

• JAVA  -xmx3550m-xms3550m-xmn2g   -xss128k
  - xmx3550m : Sets the maximum available memory for the JVM to 3550M.
  -xms3550m : Set the JVM to drive memory to 3550m. This value can be set to the same as-xmx to avoid the JVM reallocating memory after each garbage collection completes.
  -xmn2g : Set the young generation size to 2G. . The permanent average fixed size is 64m, so increasing the younger generation will reduce the size of older generations. This value has a large impact on system performance, and Sun's official recommendation is 3/8 for the entire heap.
  -xss128k : Sets the stack size for each thread. After JDK5.0, each thread has a stack size of 1M, before each thread has a stack size of 256K. The size of the memory required for the more applied threads to be adjusted. In the same physical memory, reducing this value can generate more threads. However, the operating system of the number of threads within a process is still limited, can not be generated indefinitely, the empirical value of 3000~5000 around.
  

• JAVA-XMX3550M-XMS3550M-XSS128K  -xx:newratio=4-xx : Survivorratio=4-xx:maxpermsize=16m-xx:maxtenuringthreshold=0
  -xx:newratio=4 : Sets the ratio of the young generation (including Eden and two survivor zones) to the old generation (except for the persistent generation). Set to 4, the ratio of the young generation to the old generation is 1:4, and the young generation occupies the entire stack of 1/5
  -xx:survivorratio=4 : Sets the ratio between the Eden and survivor areas in the young generation. Set to 4, the ratio of two survivor to one Eden area is 2:4, and one survivor area represents the entire young generation of 1/6
  - xx:maxpermsize=16m : Sets the durable generation size to 16m.
  -xx:maxtenuringthreshold=0 : Set the maximum age for garbage. to increase the introduction of recycling in the younger generation.

4. Collector Selection
   The JVM gives three choices: the serial collector, the parallel collector, the concurrent collector , but the serial collector is only available for small amounts of data, so the choice here is primarily for the parallel collector and the concurrency collector. By default, JDK5.0 used a serial collector before, and if you want to use a different collector, you need to add the appropriate parameters at startup. After JDK5.0, the JVM is judged based on the current system configuration.

• java-xmx3550m-xms3550m-xmn2g-xss128k-xx:parallelgcthreads=20 -XX:+USECONCMARKSWEEPGC-XX:+USEPARNEWGC
  -XX:+USECONCMARKSWEEPGC: Set old age on behalf of concurrent collection. After configuring this in the test, the configuration of the-xx:newratio=4 is invalid for unknown reasons. Therefore, at this time the younger generation size is best set with-XMN.
  -XX:+USEPARNEWGC: Set Young on behalf of the parallel collection. Can be used concurrently with CMS collection. JDK5.0 above, the JVM will set itself according to the system configuration, so it is no longer necessary to set this value.

• JAVA-XMX3550M-XMS3550M-XMN2G-XSS128K-XX:+USECONCMARKSWEEPGC   -XX:CMSFULLGCSBEFORECOMPACTION=5  - Xx:+usecmscompactatfullcollection
  -XX: Cmsfullgcsbeforecompaction : Because the concurrency collector does not compress and defragment the memory space, running a period of time will result in "fragmentation", which makes the operation less efficient. This value sets how many times a GC is run to compress and defragment the memory space.
  -xx:+usecmscompactatfullcollection : Turns on compression for older generations. Performance may be affected, but fragmentation can be eliminated

• JAVA-XMX3800M-XMS3800M-XMN2G-XSS128K  -xx:+ Useparallelgc-xx:parallelgcthreads=20
  -xx:+useparallelgc : Select the garbage collector as the parallel collector. -xx:parallelgcthreads=20 : Configure the number of threads for the parallel collector, that is, how many threads are garbage collected together. This value is best configured to be equal to the number of processors.
  

• java-xmx3550m-xms3550m-xmn2g-xss128k-xx:+useparallelgc-xx:parallelgcthreads=20 -XX:+USEPARALLELOLDGC
  -XX:+USEPARALLELOLDGC : Configure the old Generation garbage collection method for parallel collection. JDK6.0 supports parallel collection of older generations.
  

• JAVA-XMX3550M-XMS3550M-XMN2G-XSS128K-XX:+USEPARALLELGC -xx:maxgcpausemillis=100
  -xx:maxgcpausemillis=100 : Sets the maximum time for each young generation of garbage collection, and if this time is not met, the JVM automatically adjusts the younger generation size to meet this value.
  

• java-xmx3550m-xms3550m-xmn2g-xss128k-xx:+useparallelgc-xx:maxgcpausemillis=100 -xx:+useadaptivesizepolicy
  -xx:+useadaptivesizepolicy: When this option is set, the parallel collector automatically selects the size of the young generation and the corresponding Survivor area scale to achieve the minimum corresponding time specified by the target system or the collection frequency, etc., when this value is recommended when using a parallel collector, Always open.

1. throughput-First parallel collector
   As mentioned above, the parallel collector is mainly aimed at reaching a certain throughput, and is suitable for science and technology and background processing.
   Typical configuration :

2. Concurrency collector with response time Precedence
   As mentioned above, the concurrency collector is mainly to ensure the response time of the system, reduce the time of the garbage collection downtime. It is suitable for application server, telecom field and so on.
   Typical configuration :

6. Ancillary information
   The JVM provides a number of command-line arguments to print information for debugging purposes. There are mainly the following:

• -xx:+printgc
  Output form : [GC 118250k->113543k (130112K), 0.0094143 secs]

  [Full GC 121376k->10414k (130112K), 0.0650971 secs]

• -xx:+printgcdetails
  Output form : [GC [defnew:8614k->781k (9088K), 0.0123035 secs] 118250k->113543k (130112K), 0.0124633 secs]

  [GC [defnew:8614k->8614k (9088K), 0.0000665 secs][tenured:112761k->10414k (121024K), 0.0433488 secs] 121376k- >10414k (130112K), 0.0436268 secs]

• -xx:+printgctimestamps -xx:+printgc:printgctimestamps can be mixed with the above two
  Output form:11.851: [GC 98328k->93620k (130112K), 0.0082960 secs]
  

• -xx:+printgcapplicationconcurrenttime: The execution time of the program is not interrupted before each garbage collection is printed. Can be mixed with the above
  Output form:application time:0.5291524 seconds
  

• -xx:+printgcapplicationstoppedtime: The time the program was paused during the print garbage collection. Can be mixed with the above
  Output form: Total time forwhich application threads were stopped:0.0468229 seconds
  

• -XX:PRINTHEAPATGC: detailed stack information before and after the GC is printed
  Output form:
  34.702: [GC {HEAP before GC invocations=7:
  def New Generation Total 55296K, used 52568K [0x1ebd0000, 0x227d0000, 0x227d0000)
  Eden Space 49152K, 99% used[0x1ebd0000, 0x21bce430, 0x21bd0000]
  From space 6144K, 55% used[0x221d0000, 0x22527e10, 0x227d0000]
  To space 6144K, 0% used [0x21bd0000, 0x21bd0000, 0x221d0000)
  Tenured generation total 69632K, used 2696K [0x227d0000, 0x26bd0000, 0x26bd0000)
  the space 69632K, 3% used[0x227d0000, 0x22a720f8, 0x22a72200, 0x26bd0000]
  Compacting Perm Gen Total 8192K, used 2898K [0x26bd0000, 0x273d0000, 0x2abd0000)
  The space 8192K, 35% used [0x26bd0000, 0x26ea4ba8, 0X26EA4C00, 0x273d0000)
  Ro space 8192K, 66% used [0x2abd0000, 0X2B12BCC0, 0x2b12be00, 0x2b3d0000)
  RW Space 12288K, 46% used [0x2b3d0000, 0x2b972060, 0x2b972200, 0x2bfd0000)
  34.735: [defnew:52568k->3433k (55296K), 0.0072126 secs] 55264k->6615k (124928K)Heap after GC invocations=8:
  def New Generation Total 55296K, used 3433K [0x1ebd0000, 0x227d0000, 0x227d0000)
  Eden Space 49152K, 0% used[0x1ebd0000, 0x1ebd0000, 0x21bd0000]
  From space 6144K, 55% used [0x21bd0000, 0x21f2a5e8, 0x221d0000)
  To space 6144K, 0% used [0x221d0000, 0x221d0000, 0x227d0000)
  Tenured generation total 69632K, used 3182K [0x227d0000, 0x26bd0000, 0x26bd0000)
  the space 69632K, 4% used[0x227d0000, 0x22aeb958, 0x22aeba00, 0x26bd0000]
  Compacting Perm Gen Total 8192K, used 2898K [0x26bd0000, 0x273d0000, 0x2abd0000)
  The space 8192K, 35% used [0x26bd0000, 0x26ea4ba8, 0X26EA4C00, 0x273d0000)
  Ro space 8192K, 66% used [0x2abd0000, 0X2B12BCC0, 0x2b12be00, 0x2b3d0000)
  RW Space 12288K, 46% used [0x2b3d0000, 0x2b972060, 0x2b972200, 0x2bfd0000)
  }
  , 0.0757599 secs]

• -xloggc:filename: In conjunction with the above several, log information to the file for analysis.

8. Common configuration rollups

• -xx:+cmsincrementalmode: Set to incremental mode. Applies to single CPU conditions.

• -xx:parallelgcthreads=n: Set the concurrency collector the number of CPUs used by the young generation collection method for parallel collection. The number of parallel collection threads.

• -xx:parallelgcthreads=n: Sets the number of CPUs to use when the parallel collector is collected. The number of parallel collection threads.

• -xx:maxgcpausemillis=n: Set maximum pause time for parallel collection

• -xx:gctimeratio=n: Sets the percentage of time that garbage collection takes to run the program. The formula is 1/(1+n)

• -xx:+printgc

• -xx:+printgcdetails

• -xx:+printgctimestamps

• -xloggc:filename

• -XX:+USESERIALGC: Setting up the serial collector

• -XX:+USEPARALLELGC: Setting up a parallel collector

• -XX:+USEPARALLEDLOLDGC: Setting up a parallel old generation collector

• -XX:+USECONCMARKSWEEPGC: Setting the concurrency Collector

• -xms: initial heap Size

• -xmx: Maximum heap Size

• -xx:newsize=n: Setting the young generation size

• -xx:newratio=n: Sets the ratio of the younger generation to the older generation. such as: 3, the ratio of the young generation and the old generation is 1:3, the young generation of the entire young generation of old generation and 1/4

• -xx:survivorratio=n: The ratio of Eden in the young generation to the two survivor districts. Note that there are two survivor districts. such as: 3, indicating Eden:survivor=3:2, a Survivor area accounted for the entire young generation of 1/5

• -xx:maxpermsize=n: Setting the persistent generation size

1. Heap Settings

2. Collector Settings

3. Garbage collection Statistics

4. Parallel collector settings

5. Concurrent collector Settings

Iv. Summary of tuning

2. Young Generation Size Selection

• Response Time-First application : as large as possible until the minimum response time limit of the system is approached (depending on the actual situation). In such cases, the frequency at which the young generation collects occurs is also minimal. At the same time, reduce the reach of older generations of objects.

• throughput-First application : as large as possible, may reach Gbit degree. Because there is no requirement for response time, garbage collection can be done in parallel, generally suitable for applications over 8CPU.

4. Elder Generation Size Selection

• Concurrent garbage Collection Information

• Persistent generation concurrent Collection times

• Traditional GC Information

• The proportion of time spent in the collection of young and old generations

• Response Time-first application : Older generations Use the concurrency collector, so the size needs to be set carefully, and some parameters, such as concurrent session rate and session duration , are generally considered. If the heap setting is small, it can result in memory fragmentation, high recovery frequency, and application pauses using traditional markup cleanup, and if the heap is large, a longer collection time is required. The most optimized scenario typically requires a reference to the following data: Reducing the time spent by younger generations and older generations generally increases the efficiency of the application

• throughput-First applications : General throughput priority applications have a very large young generation and a smaller old generation. The reason for this is that the majority of short-term objects can be recovered as much as possible, reducing medium-term objects, while older generations store long-lived objects.

6. Fragmentation problems caused by smaller heaps
   The heap is not compressed because the old generation of concurrent collectors uses tags and clears the algorithm. When the collector recycles, he merges the adjacent space so that it can be assigned to a larger object. However, when the heap space is small, after a period of time, "fragmentation" occurs, if the concurrent collector does not find enough space, then the concurrent collector will stop, and then use the traditional token, purging method for recycling. If "Fragmentation" occurs, you may need to configure the following:

• -xx:+usecmscompactatfullcollection: When using the concurrency collector, the compression of older generations is turned on.

• -xx:cmsfullgcsbeforecompaction=0: When the above configuration is on, how many times the full GC is set, the old generation is compressed

JVM Tuning Summary-XMS-XMX-XMN-XSS