Java 1.7 G1 Garbage Collector;

Aasim Naseem 7

Hi All;
Hope everything is going good at your desks;

Last night, I was reading new features in Java 1.7 and found some updates in garbage collection mechanism; There are many updates in 1.7 ranges from core vm, i18n, Nimbus for Swings and other enhancements; We have already discussed the updates in GC for Java SE 6 Update 14; You can find them here; In Java 1.7 have a new garbage collection strategy called G1, which is short for Garbage First. It has been experimentally launched in the Java 1.6 update 14 to replace the regular Concurrent Mark and Sweep Garbage Collectors with increased performance.

G1 is considered as “server centric” with following attributes.

  • G1 uses parallelism which are mostly used in hardware today.The main advantage of G1 is designed in such a way to make use of all available CPU’s and utilize the processing power of all CPU’s and increase the performance and speed in Garbage Collection.
  • Concurrency feature of G1 allows to run Java threads to minimize the heap operations at stop pauses.
  • Next feature which plays a key role in increasing the Garbage Collection is treating the young objects(newly created) and the old objects(which lived for some time) differently.G1 mainly focuses on young objects as they can be reclaimable when traversing the old objects.
  • Heap compaction is done to eliminate fragmentation problems.
  • G1 can be more predictable when compared to CMS.

Features of G1 Garbage Collector

  • A single contiguous heap which is split into same-sized regions. No separation between younger and older regions.
  • G1 uses evacuation pauses.Evacuation pauses are done in parallel by using all the available processors.
  • G1 uses a pause prediction model to meet user-defined pause time targets
  • Like CMS,G1 also periodically performs a concurrent marking phase.
  • Unlike CMS, G1 does not perform a concurrent sweeping phase.
Here are some elaborated details
  • Parallelism and Concurrency. G1 takes advantage of the parallelism that exists in hardware today. It uses all available CPUs (cores, hardware threads, etc.) to speed up its “stop-the-world” pauses when an application’s Java threads are stopped to enable GC. It also works concurrently with running Java threads to minimize whole-heap operations during stop-the-world pauses.
  • Generational. Like the other HotSpot GC’s, G1 is generational, meaning it treats newly-allocated (aka young) objects and objects that have lived for some time (aka old) differently. It concentrates garbage collection activity on young objects, as they are the ones most likely to be reclaimable, while visiting old objects infrequently. For most Java applications, generational garbage collection has major efficiency advantages over alternative schemes.
  • Compaction. Unlike CMS, G1 performs heap compaction over time. Compaction eliminates potential fragmentation problems to ensure smooth and consistent long-running operation.
  • Predictability. G1 is expected to be more predictable than CMS. This is largely due to the elimination of fragmentation issues that can negatively affect stop-the-world pause times in CMS. Additionally, G1 has a pause prediction model that, in many situations, allows it to often meet (or rarely exceed) a pause time target.

free counters

Comments 7

  1. It’s actually a cool and useful piece of info. I am glad that you
    just shared this helpful info with us. Please stay us up to date like this.
    Thank you for sharing.

  2. You have made some really good points there.
    I checked on the internet for more info about the issue and found most
    people will go along with your views on this web site.

  3. whoah this weblog is wonderful i like reading your articles.
    Stay up the good work! You recognize, many people are looking around
    for this info, you could help them greatly.

Leave a Reply

Your email address will not be published.