Basic GC Tuning
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.
- By default, then, the young generation starts out
- -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的更多相关文章
- GC和GC Tuning
GC和GC Tuning GC的基础知识 什么是垃圾 C语言申请内存:malloc free C++: new delete c/C++ 手动回收内存 Java: new ? 自动内存回收,编程上简单 ...
- 提交并发量的方法:Java GC tuning :Garbage collector
三色算法,高效率垃圾回收,jvm调优 Garbage collector:垃圾回收器 What garbage? 没有任何引用指向它的对象 JVM GC回收算法: 引用计数法(ReferenceCou ...
- Java 8 VM GC Tuning Guide Charter2
第二章 Ergonomics Ergonomics is the process by which the Java Virtual Machine (JVM) and garbage collect ...
- 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 ...
- Understanding CMS GC Logs--转载
原文地址:https://blogs.oracle.com/poonam/entry/understanding_cms_gc_logs Understanding CMS GC Logs By Po ...
- Tuning Spark
https://spark.apache.org/docs/1.2.1/tuning.html Data Serialization 数据序列化,对于任意分布式系统都是性能的关键点 Spark默认使用 ...
- 【转载】为什么不建议<=3G的情况下使用CMS GC
之前曾经有讲过在heap size<=3G的情况下完全不要考虑CMS GC,在heap size>3G的情况下也优先选择ParallelOldGC,而不是CMS GC,只有在暂停时间无法接 ...
- jvm系列(十):如何优化Java GC「译」
本文由CrowHawk翻译,是Java GC调优的经典佳作. 本文翻译自Sangmin Lee发表在Cubrid上的"Become a Java GC Expert"系列文章的第三 ...
- Java GC性能优化实战
GC优化是必要的吗? 或者更准确地说,GC优化对Java基础服务来说是必要的吗?答案是否定的,事实上GC优化对Java基础服务来说在有些场合是可以省去的,但前提是这些正在运行的Java系统,必须包含以 ...
随机推荐
- 内部类访问局部变量为什么必须要用final修饰
内部类访问局部变量为什么必须要用final修饰 看了大概五六篇博客, 讲的内容都差不多, 讲的内容也都很对, 但我觉得有些跑题了 略叙一下 String s = "hello"; ...
- Spring(二)继承jdbcDaoSupport的方式实现(增删改查)
一 首先创建数据库表和相应的字段,并创建约束 二 建立项目,导入jar包(ioc,aop,dao,数据库驱动,连接池)并且将applicationContext.xml文件放在src下 三 开启组件扫 ...
- javascript常用的41个经典技巧
1. 将彻底屏蔽鼠标右键 <table border oncontextmenu=return(false)><td>no</table> 可用于Table 2. ...
- Mysql 数据库常用配置命令
1.查看mysql数据库默认编码: mysql> show variables like "character%"; +--------------------------+ ...
- 仿9GAG制作过程(四)
有话要说: 这次主要讲述主页面下拉刷新和上拉加载功能的实现. 主要是使用了SwipeRefreshLayout的布局方式,并在此基础上通过RecyclerView的特性增加了上拉加载的功能. 成果: ...
- C#中的yield return用法演示源码
下边代码段是关于C#中的yield return用法演示的代码. using System;using System.Collections;using System.Collections.Gene ...
- 南京邮电大学java第三次实验报告
实 验 报 告 ( 2017 / 2018学年 第2学期) 课程名称 JAVA语言程序设计 实验名称 Java集成开发环境的安装与使用. Java变量.表达式与控制结构 实验时间 2018 年 4 月 ...
- redis的几种数据导入导出方式【转】
环境说明:202.102.221.11 redis源实例202.102.221.12 redis目标实例202.102.221.13 任意linux系统 一.redis-dump方式 1.安装redi ...
- python(day16)内置函数,匿名函数
# add = lambda x,y:x+y # print(add(1,2)) # dic={'k1':10,'k2':100,'k3':30} # def func(key): # return ...
- 【English】一、专治各种英语不服
一.前言 英语虽然不是使用人数最多的语言,但是...谁叫我是一名码农且英语垃圾呢. 二.开始 1. read sb sth = read sth for sb read sb sth 是双宾语结构. ...