Sizing the Heap

  • -XmsN
  • -XmxN

Summary

  • The JVM will attempt to find a reasonable minimum and maximum 
    heap size based on the machine it is running on.
  • Unless the application needs a larger heap than the default, consider 
    tuning the performance goals of a GC algorithm (given in 
    the next chapter) rather than fine-tuning the heap size.

Sizing the Generations

  • -XX:NewRatio=N

    • Set the ratio of the young generation to the old generation.
    • default value of 2.
    • Initial Young Gen Size = Initial Heap Size / (1 + NewRatio) 
      • By default, then, the young generation starts out 
        at 33% of the initial heap size.
  • -XX:NewSize=N 
    • Set the initial size of the young generation.
    • If that option NewSize flag is set, it will take precedence over the value calculated fromthe NewRatio.
  • -XX:MaxNewSize=N 
    • Set the maximum size of the young generation.
    • By default, that maximum is also set using the 
      NewRatio value, though it is based on the maximum (rather than initial) heap size.
  • -XmnN 
    • Shorthand for setting both NewSize and MaxNewSize to the same value.
    • When a heap size is fixed (by setting -Xms equal to -Xmx),it is usually preferable to use -Xmn to specify a fixed size for the young generation as well.

Summary

  • Within the overall heap size, the sizes of the generations are 
    controlled by how much space is allocated to the young generation.
  • The young generation will grow in tandem with the overall heap 
    size, but it can also fluctuate as a percentage of the total heap 
    (based on the initial and maximum size of the young generation).

Sizing Permgen and Metaspace

  • When the JVM loads classes, it must keep track of certain metadata about those classes. 
    From the perspective of an end user, this is all just bookkeeping information. This data 
    is held in a separate heap space. In Java 7, this is called the permgen (or permanent 
    generation), and in Java 8, this is called the metaspace.
  • Permgen and metaspace are not exactly the same thing. In Java 7, permgen contains 
    some miscellaneous objects that are unrelated to class data; these are moved into the 
    regular heap in Java 8. As end users, all we need to know is that permgen/metaspace holds a bunch of class-related data, and that there are certain circumstances where the size of that region needs to be tuned.
  • Note that permgen/metaspace does not hold the actual instance of the class (the Class 
    objects), nor reflection objects (e.g., Method objects); those are held in the regular heap. 
    Information in permgen/metaspace is really only used by the compiler and JVM runtime, 
    and the data it holds is referred to as class metadata.
  • the metaspace rarely needs to be sized—because (unlike permgen) metaspace will by default use as much space as it needs.
  • These memory regions behave just like a separate instance of the regular heap. They are 
    sized dynamically based on an initial size and will increase as needed to a maximum size.
  • permgen, 
    • -XX:PermSize=N and -XX:MaxPermSize=N.
  • Metaspace 
    • -XX:MetaspaceSize=N and -XX:MaxMetaspaceSize=N.
  • Default maximum metaspace size Unlimited 
    • Because the default size of metaspace is unlimited, there is the possibility (particularly in a 32-bit JVM) that a Java 8 application can run out of memory by filling up metaspace.
  • Heap dumps can be used to diagnose what classloaders exist, which in 
    turn can help determine if a classloader leak is filling up permgen (or metaspace). 
    Otherwise, jmap can be used with the argument -permstat (in Java 7) or -clstats (in 
    Java 8) to print out information about the classloaders.

Summary

  • The permanent generation or metaspace holds class metadata (not class data itself). It behaves like a separate heap.
  • For typical applications that do not load classes after startup, the initial size of this region can be based on its usage after all classes have been loaded. That will slightly speed up startup.
  • Application servers doing development (or any environment where classes are frequently redefined) will see an occasional full GC caused when permgen/metaspace fills up and old class metadata is discarded.

Controlling Parallelism

  • All GC algorithms except the serial collector use multiple threads. The number of these 
    threads is controlled by the -XX:ParallelGCThreads=N flag. The value of this flag affects 
    the number of threads used for the following operations:

    • Collection of the young generation when using -XX:+UseParallelGC
    • Collection of the old generation when using -XX:+UseParallelOldGC
    • Collection of the young generation when using -XX:+UseParNewGC
    • Collection of the young generation when using -XX:+UseG1GC
    • Stop-the-world phases of CMS (though not full GCs)
    • Stop-the-world phases of G1 (though not full GCs)
  • Because these GC operations stop the application threads from executing, the JVM 
    attempts to use as many CPU resources as it can in order to minimize the pause time. 
    By default, that means the JVM will run one thread for each CPU on a machine, up to 
    eight. Once that threshold has been reached, the JVM only adds a new thread for every 
    five-eighths of a CPU. So the total number of threads (where N is the number of CPUs) 
    on a machine with more than eight CPUs is: 
    • ParallelGCThreads = 8 + ((N - 8) * 5 / 8)
  • Note that this flag does not set the number of background threads used by CMS or G1

Summary

  • The basic number of threads used by all GC algorithms is based 
    on the number of CPUs on a machine.
  • When multiple JVMs are run on a single machine, that number 
    will be too high and must be reduced.

Adaptive Sizing

  • The sizes of the heap, the generations, and the survivor spaces can vary during execution 
    as the JVM attempts to find the optimal performance according to its policies and 
    tunings.
  • This is a best-effort solution, and it relies on past performance: the assumption is that 
    future GC cycles will look similar to the GC cycles in the recent past. That turns out to 
    be a reasonable assumption for many workloads, and even if the allocation rate suddenly 
    changes, the JVM will readapt its sizes based on the new information.
  • At a global level, adaptive sizing is disabled by turning off the -XX:-UseAdaptiveSize 
    Policy flag (which is true by default). With the exception of the survivor spaces (which 
    are examined in detail in the next chapter), adaptive sizing is also effectively turned off 
    if the minimum and maximum heap sizes are set to the same value, and the initial and 
    maximum sizes of the new generation are set to the same value.

Summary

  • Adaptive sizing controls how the JVM alters the ratio of young 
    generation to old generation within the heap.
  • Adaptive sizing should generally be kept enabled, since adjusting 
    those generation sizes is how GC algorithms attempt to meet 
    their pause time goals.
  • For finely tuned heaps, adaptive sizing can be disabled for a small 
    performance boost.

Basic GC Tuning的更多相关文章

  1. GC和GC Tuning

    GC和GC Tuning GC的基础知识 什么是垃圾 C语言申请内存:malloc free C++: new delete c/C++ 手动回收内存 Java: new ? 自动内存回收,编程上简单 ...

  2. 提交并发量的方法:Java GC tuning :Garbage collector

    三色算法,高效率垃圾回收,jvm调优 Garbage collector:垃圾回收器 What garbage? 没有任何引用指向它的对象 JVM GC回收算法: 引用计数法(ReferenceCou ...

  3. Java 8 VM GC Tuning Guide Charter2

    第二章 Ergonomics Ergonomics is the process by which the Java Virtual Machine (JVM) and garbage collect ...

  4. Java 8 VM GC Tuning Guide Charter3-4

    第三章 Generations One strength of the Java SE platform is that it shields the developer from the compl ...

  5. Understanding CMS GC Logs--转载

    原文地址:https://blogs.oracle.com/poonam/entry/understanding_cms_gc_logs Understanding CMS GC Logs By Po ...

  6. Tuning Spark

    https://spark.apache.org/docs/1.2.1/tuning.html Data Serialization 数据序列化,对于任意分布式系统都是性能的关键点 Spark默认使用 ...

  7. 【转载】为什么不建议<=3G的情况下使用CMS GC

    之前曾经有讲过在heap size<=3G的情况下完全不要考虑CMS GC,在heap size>3G的情况下也优先选择ParallelOldGC,而不是CMS GC,只有在暂停时间无法接 ...

  8. jvm系列(十):如何优化Java GC「译」

    本文由CrowHawk翻译,是Java GC调优的经典佳作. 本文翻译自Sangmin Lee发表在Cubrid上的"Become a Java GC Expert"系列文章的第三 ...

  9. Java GC性能优化实战

    GC优化是必要的吗? 或者更准确地说,GC优化对Java基础服务来说是必要的吗?答案是否定的,事实上GC优化对Java基础服务来说在有些场合是可以省去的,但前提是这些正在运行的Java系统,必须包含以 ...

随机推荐

  1. 内部类访问局部变量为什么必须要用final修饰

    内部类访问局部变量为什么必须要用final修饰 看了大概五六篇博客, 讲的内容都差不多, 讲的内容也都很对, 但我觉得有些跑题了 略叙一下 String s = "hello"; ...

  2. Spring(二)继承jdbcDaoSupport的方式实现(增删改查)

    一 首先创建数据库表和相应的字段,并创建约束 二 建立项目,导入jar包(ioc,aop,dao,数据库驱动,连接池)并且将applicationContext.xml文件放在src下 三 开启组件扫 ...

  3. javascript常用的41个经典技巧

    1. 将彻底屏蔽鼠标右键 <table border oncontextmenu=return(false)><td>no</table> 可用于Table 2. ...

  4. Mysql 数据库常用配置命令

    1.查看mysql数据库默认编码: mysql> show variables like "character%"; +--------------------------+ ...

  5. 仿9GAG制作过程(四)

    有话要说: 这次主要讲述主页面下拉刷新和上拉加载功能的实现. 主要是使用了SwipeRefreshLayout的布局方式,并在此基础上通过RecyclerView的特性增加了上拉加载的功能. 成果: ...

  6. C#中的yield return用法演示源码

    下边代码段是关于C#中的yield return用法演示的代码. using System;using System.Collections;using System.Collections.Gene ...

  7. 南京邮电大学java第三次实验报告

    实 验 报 告 ( 2017 / 2018学年 第2学期) 课程名称 JAVA语言程序设计 实验名称 Java集成开发环境的安装与使用. Java变量.表达式与控制结构 实验时间 2018 年 4 月 ...

  8. redis的几种数据导入导出方式【转】

    环境说明:202.102.221.11 redis源实例202.102.221.12 redis目标实例202.102.221.13 任意linux系统 一.redis-dump方式 1.安装redi ...

  9. python(day16)内置函数,匿名函数

    # add = lambda x,y:x+y # print(add(1,2)) # dic={'k1':10,'k2':100,'k3':30} # def func(key): # return ...

  10. 【English】一、专治各种英语不服

    一.前言 英语虽然不是使用人数最多的语言,但是...谁叫我是一名码农且英语垃圾呢. 二.开始 1. read sb sth = read sth for sb read sb sth 是双宾语结构. ...