Java 7 has been out for a while now, but I cannot find any good resources on the configuration of the garbage collectors, specifically the new G1 collector.
My questions:
- Is G1 the default collector in Java 7 and if not how do I activate G1?
- What optional settings does g1 have in Java7?
- Were there any changes made to other collectors like cms or the parallel collector in Java 7?
- Where can I find good documentation on garbage collection in Java 7?
The G1 garbage collector is not the default in my installation of Java, version 1.7.0_01. You can see for yourself by using with some extra command line options:
> java -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -version
-XX:InitialHeapSize=132304640 -XX:MaxHeapSize=2116874240 -XX:ParallelGCThreads=4 -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC
java version "1.7.0_01"
Java(TM) SE Runtime Environment (build 1.7.0_01-b08)
Java HotSpot(TM) 64-Bit Server VM (build 21.1-b02, mixed mode)
Heap
PSYoungGen total 37696K, used 1293K [0x00000007d5eb0000, 0x00000007d88c0000, 0x0000000800000000)
eden space 32320K, 4% used [0x00000007d5eb0000,0x00000007d5ff3408,0x00000007d7e40000)
from space 5376K, 0% used [0x00000007d8380000,0x00000007d8380000,0x00000007d88c0000)
to space 5376K, 0% used [0x00000007d7e40000,0x00000007d7e40000,0x00000007d8380000)
PSOldGen total 86144K, used 0K [0x0000000781c00000, 0x0000000787020000, 0x00000007d5eb0000)
object space 86144K, 0% used [0x0000000781c00000,0x0000000781c00000,0x0000000787020000)
PSPermGen total 21248K, used 2032K [0x000000077ca00000, 0x000000077dec0000, 0x0000000781c00000)
object space 21248K, 9% used [0x000000077ca00000,0x000000077cbfc288,0x000000077dec0000)
You don't need to enable experimental options to turn on the G1 collector any more, though:
> java -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseG1GC -version
-XX:InitialHeapSize=132304640 -XX:MaxHeapSize=2116874240 -XX:+PrintCommandLineFlags -XX:+PrintGCDetails -XX:+UseCompressedOops -XX:+UseG1GC -XX:-UseLargePagesIndividualAllocation
java version "1.7.0_01"
Java(TM) SE Runtime Environment (build 1.7.0_01-b08)
Java HotSpot(TM) 64-Bit Server VM (build 21.1-b02, mixed mode)
Heap
garbage-first heap total 130048K, used 0K [0x000000077ca00000, 0x0000000784900000, 0x00000007fae00000)
region size 1024K, 1 young (1024K), 0 survivors (0K)
compacting perm gen total 20480K, used 2032K [0x00000007fae00000, 0x00000007fc200000, 0x0000000800000000)
the space 20480K, 9% used [0x00000007fae00000, 0x00000007faffc288, 0x00000007faffc400, 0x00000007fc200000)
No shared spaces configured.
I don't know where you can find any good documentation.
Oracle finally made G1 official in Java 7 U4: http://www.oracle.com/technetwork/java/javase/7u4-relnotes-1575007.html
Description: http://docs.oracle.com/javase/7/docs/technotes/guides/vm/G1.html
Command line options: http://www.oracle.com/technetwork/java/javase/tech/vmoptions-jsp-140102.html#G1Options
Still, I do not think it is the default collector in Java 7. For servers the default is the Parallel Collector as in Java 6.
Yes, G1 is the new standard garbage collector in Java 1.7 JVM.
Here you can find plenty of information on how to use and configre the new garbage collector:
Using G1 G1 is still considered experimental and can be enabled with the following two parameters:
-XX:+UnlockExperimentalVMOptions -XX:+UseG1GC
To set a GC pause time goal, use the following parameter:
-XX:MaxGCPauseMillis =50 (for a pause time target of 50ms)
With G1, a time interval can be specified during which a GC pause should last no longer than the time given above:
-XX:GCPauseIntervalMillis =200 (for a pause interval target of 200ms)
Note that the above two options represent goals, not promises or guarantees. They might work well in some situations but not in others, and the GC might not always be able to obey them.
Alternatively, the size of the young generation can be specified explicitly to impact evacuation pause times:
-XX:+G1YoungGenSize=512m (for a 512 megabyte young generation)
G1 also uses the equivalent of survivor spaces, which are, naturally, a set of (potentially non-contiguous) regions. Their size can be specified with the usual parameters (e.g., -XX:SurvivorRatio=6).
Finally, to run G1 at its full potential, try setting these two parameters which are currently disabled by default because they may uncover a rare race condition:
-XX:+G1ParallelRSetUpdatingEnabled -XX:+G1ParallelRSetScanningEnabled
One more thing to note is that G1 is very verbose compared to other HotSpot GCs when -XX:+PrintGCDetails is set. This is because it prints per-GC-thread timings and other information very helpful in profiling and trouble-shooting. If you want a more concise GC log, please switch to using -verbosegc (though it is recommended that the more detailed GC log be obtained).
I have also found this article very helpful in understanding the inners of G1.
Even more info here.
1. Is G1 the default collector in Java 7 (...)
The rule on this Java 5 page is still applicable in Java 7 (and AFAIK, Java 8):
On server-class machines running the server VM, the garbage collector (GC) has changed from the previous serial collector (-XX:+UseSerialGC) to a parallel collector (-XX:+UseParallelGC).
But also consider:
- 64-bit JVMs do not come with a
-clientVM, so are always "server class" - Since Java 7, using -XX:+UseParallelGC (whether set or implied) additionally implies -XX:+UseParallelOldGC (i.e. unless explicitly disabled)
For example, if on Windows x64 you run...
- Java 7 64-bit, you get Parallel GC (for both young and old generations) by default.
- Java 8 32-bit, you get Serial GC (for both generations) by default
1. (...) how do I activate G1?
As of Java 7, simply -XX:+UseG1GC. Perhaps also of interest is when you would want to:
Applications running today with either the CMS or the ParallelOld garbage collector would benefit switching to G1 if the application has one or more of the following traits.
- More than 50% of the Java heap is occupied with live data.
- The rate of object allocation rate or promotion varies significantly.
- Undesired long garbage collection or compaction pauses (longer than 0.5 to 1 second)
2. What optional settings does g1 have in Java7?
I've not used G1 myself, but I gather that it adheres to the same basic "throughput / ergonomic" flags used to tune the other parallel collectors. In my experience with the Parallel GC, -XX:GCTimeRatio has been the pivotal one in providing the expected speed-memory tradeoff. YMMV.
G1-specific options are listed here
3. Were there changes to (...) cms or the parallel collector in Java 7?
Don't know, but...
G1 is planned as the long term replacement for the Concurrent Mark-Sweep Collector (CMS)
4. Where can I find good documentation on garbage collection in Java 7?
It can be a pain to find, can't it? Probably the best "hub" page I've found is this one:
http://www.oracle.com/technetwork/java/javase/tech/index-jsp-140228.html
Some deep reading required, but worth the time if you need to do some tuning. Particularly insightful is: Garbage Collector Ergonomics
- Is G1 the default collector in Java 7 and if not how do I activate G1?
G1 is not default collector in Java 7. -XX:+UseG1GC will enable G1GC
- What optional settings does g1 have in Java7?
There are many. Have a look at this oracle article for complete information.
The G1 GC is an adaptive garbage collector with defaults that enable it to work efficiently without modification.
Due to this reason, customize critical parameters
-XX:MaxGCPauseMillis
-XX:G1HeapRegionSize
-XX:ParallelGCThreads
-XX:ConcGCThreads
and leave all other parameters to default value.
Here is a list of important options and their default values. This list applies to the latest Java HotSpot VM, build 24. You can adapt and tune the G1 GC settings on the JVM command line.
Important Defaults:
-XX:G1HeapRegionSize=n
Sets the size of a G1 region. The value will be a power of two and can range from 1MB to 32MB. The goal is to have around 2048 regions based on the minimum Java heap size.
-XX:MaxGCPauseMillis=200
Sets a target value for desired maximum pause time. The default value is 200 milliseconds. The specified value does not adapt to your heap size.
-XX:G1NewSizePercent=5
Sets the percentage of the heap to use as the minimum for the young generation size. The default value is 5 percent of your Java heap.
-XX:G1MaxNewSizePercent=60
Sets the percentage of the heap size to use as the maximum for young generation size. The default value is 60 percent of your Java heap.
-XX:ParallelGCThreads=n
Sets the value of the STW worker threads. Sets the value of n to the number of logical processors. The value of n is the same as the number of logical processors up to a value of 8.
If there are more than eight logical processors, sets the value of n to approximately 5/8 of the logical processors. This works in most cases except for larger SPARC systems where the value of n can be approximately 5/16 of the logical processors.
-XX:ConcGCThreads=n
Sets the number of parallel marking threads. Sets n to approximately 1/4 of the number of parallel garbage collection threads (ParallelGCThreads).
-XX:InitiatingHeapOccupancyPercent=45
Sets the Java heap occupancy threshold that triggers a marking cycle. The default occupancy is 45 percent of the entire Java heap.
-XX:G1MixedGCLiveThresholdPercent=65
Sets the occupancy threshold for an old region to be included in a mixed garbage collection cycle. The default occupancy is 65 percent
-XX:G1HeapWastePercent=10
Sets the percentage of heap that you are willing to waste. The Java HotSpot VM does not initiate the mixed garbage collection cycle when the reclaimable percentage is less than the heap waste percentage
-XX:G1MixedGCCountTarget=8
Sets the target number of mixed garbage collections after a marking cycle to collect old regions with at most G1MixedGCLIveThresholdPercent live data. The default is 8 mixed garbage collections
-XX:G1OldCSetRegionThresholdPercent=10
Sets an upper limit on the number of old regions to be collected during a mixed garbage collection cycle. The default is 10 percent of the Java heap
-XX:G1ReservePercent=10
Sets the percentage of reserve memory to keep free so as to reduce the risk of to-space overflows. The default is 10 percent. When you increase or decrease the percentage, make sure to adjust the total Java heap by the same amount.
You have re-configured many G1GC parameters, which are not required if you follow above documentation page. Please cross check with above recommendations especially on ParallelGCThreads and ConcGCThreads, which are to be based on your CPU cores. Remove re-configuration of un-necessary parameters.
Recommendations from oracle:
When you evaluate and fine-tune G1 GC, keep the following recommendations in mind:
Young Generation Size: Avoid explicitly setting young generation size with the
-Xmnoption or any or other related option such as-XX:NewRatio. Fixing the size of the young generation overrides the target pause-time goal.Pause Time Goals: When you evaluate or tune any garbage collection, there is always a latency versus throughput trade-off. The G1 GC is an incremental garbage collector with uniform pauses, but also more overhead on the application threads. The throughput goal for the G1 GC is 90 percent application time and 10 percent garbage collection time.
- Were there any changes made to other collectors like cms or the parallel collector in Java 7?
There are some changes with Java 7. Have a look at this article
- Where can I find good documentation on garbage collection in Java 7?
Refer to oracle documentation page about gc and related SE question:
The documentation available at http://www.oracle.com/technetwork/java/javase/tech/g1-intro-jsp-135488.html (the link provided by Wojtek) seems to be the only official link with info but the info seems outdated as some of the flags mentioned there were only available in the test builds, they no longer exist in the production releases. Some one from Oracle should provide some updated documentation on the G1 GC.
No G1 is not default garbage collector in jdk 1.7.0_02. The default garbage collector depends upon the class of machine. If the machine is of Server class then the default garbage collector is Throughput Collector. If the machine is of Client class then the default garbage collector is Serial Collector.
By default you don't really want to use G1 collector, as it is not really better than the others. It is only good for special purposes.
In low latency application is is sligthly better than CMS, as it has a little bit shorter, and more predictable pause times. In exchange the throughput is much worse than CMS in exchange.
So it is only good if the latency is important, but the throughput is not important at all. If both are important, then stay with CMS.
来源：https://stackoverflow.com/questions/8111310/java-7-jdk-7-garbage-collection-and-documentation-on-g1