This is not the document you are looking for? Use the search form below to find more!

Report home > Others

Memory Management in the Java HotSpot Virtual Machine

0.00 (0 votes)
Document Description
Memory Management in the Java HotSpot Virtual Machine
File Details
  • Added: April, 14th 2011
  • Reads: 333
  • Downloads: 2
  • File size: 7.83mb
  • Pages: 21
  • Tags: language, technology, whitepaper, java, jvm
  • content preview
Submitter
  • Name: fadheela

We are unable to create an online viewer for this document. Please download the document instead.

Memory Management in the Java HotSpot Virtual Machine screenshot

Add New Comment




Related Documents

Dialogue Management in the Agreement Negotiation Process: A Model that Involves Natural Reasoning

by: shinta, 10 pages

In the paper we describe an approach to dialogue management in the agreement negotiation where one of the central roles is attributed to the model of natural human reasoning. ...

Performance Management in the Value Chain

by: samanta, 16 pages

Performance management in the value chain is a critical task for companies confronted with increasingly complex global value chain networks. Managing global material flow and shipments between ...

NRC\’s Urban Stormwater Management in the United States: Implications for MS4 Permi Holders

by: ryan, 15 pages

NRC\’s Urban Stormwater Management in the United States: Implications for MS4 Permi Holders

LIFE CYCLE DESIGN MANAGEMENT IN THE AUTOMOBILE SECTOR A FRAMEWORK

by: samanta, 10 pages

Many particular stages/impacts Life Cycle Assessment studies and some general life cycle perspective studies have been conducted in the automobile sector, as one of the most unsustainable social ...

SPECIAL EVALUATION STUDY ON PROJECT PERFORMANCE MANAGEMENT IN THE ASIAN DEVELOPMENT BANK AND ITS PROJECTS IN DEVELOPING MEMBER COUNTRIES

by: samanta, 96 pages

This report documents the findings of a special evaluation study (SES) on project performance management (PPM) in the Asian Development Bank (ADB) and the projects it funds in its developing member ...

Towards Sustainable Resource Management in the European Union

by: samanta, 50 pages

A policy framework for sustainable resource management (SRM) is required both to guarantee the materials and energy supply of the EU economy and safeguard the natural resource basis in the future. ...

Human resource management in the project-oriented company: A review

by: samanta, 9 pages

Human resource management (HRM) can be viewed as core processes of the project-oriented company, affecting the way the orga- nizationacquires and uses human resources, and how employees experience ...

Changes in The Role of Production and Operations Management in the New Economy

by: samanta, 11 pages

The paper analyses how the area of production and operations management (POM) in Brazil should change/adapt in order to remain relevant in the so called "new economy". Drawing from insights ...

Time Management in the High Level Architecture

by: samanta, 21 pages

Time management is required in simulations to ensure temporal aspects of the system under investigation are correctly reproduced by the simulation model. This paper describes the time management ...

Inside The Jvm Memory Management And Troubleshooting

by: rubadah, 51 pages

Inside The Jvm Memory Management And Troubleshooting

Content Preview
Memory Management in the JavaHotSpot™ Virtual MachineSun MicrosystemsApril 2006 2Table of ContentsSun Microsystems, Inc.Table of Contents1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 Explicit vs. Automatic Memory Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 Garbage Collection Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4Desirable Garbage Collector Characteristics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4Design Choices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Performance Metrics. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5Generational Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64 Garbage Collectors in the J2SE 5.0 HotSpot JVM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Hotspot Generations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Garbage Collection Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7Fast Allocation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Serial Collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8Parallel Collector. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9Parallel Compacting Collector. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10Concurrent Mark-Sweep (CMS) Collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 Ergonomics -- Automatic Selections and Behavior Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13Automatic Selection of Collector, Heap Sizes, and Virtual Machine . . . . . . . . . . . . . . . . . . . . . . . . . 13Behavior-based Parallel Collector Tuning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 Recommendations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15When to Select a Different Garbage Collector. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Heap Sizing. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15Tuning Strategy for the Parallel Collector . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16What to Do about OutOfMemoryError . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167 Tools to Evaluate Garbage Collection Performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17–XX:+PrintGCDetails Command Line Option . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17–XX:+PrintGCTimeStamps Command Line Option . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17jmap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17jstat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17HPROF: Heap Profiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18HAT: Heap Analysis Tool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188 Key Options Related to Garbage Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 For More Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203IntroductionSun Microsystems, Inc.1 IntroductionOne strength of the Java™ 2 Platform, Standard Edition (J2SE™) is that it performs automatic memorymanagement, thereby shielding the developer from the complexity of explicit memory management.This paper provides a broad overview of memory management in the Java HotSpot virtual machine (JVM) inSun’s J2SE 5.0 release. It describes the garbage collectors available to perform the memory management, andgives some advice regarding choosing and configuring a collector and setting sizes for the memory areas onwhich the collector operates. It also serves as a resource, listing some of the most commonly-used options thataffect garbage collector behavior and providing numerous links to more detailed documentation.Section 2 is for readers who are new to the concept of automatic memory management. It has a brief discussionof the benefits of such management versus requiring programmers to explicitly deallocate space for data.Section 3 then presents an overview of general garbage collection concepts, design choices, and performancemetrics. It also introduces a commonly-used organization of memory into different areas called generationsbased on the expected lifetimes of objects. This separation into generations has proven effective at reducinggarbage collection pause times and overall costs in a wide range of applications.The rest of the paper provides information specific to the HotSpot JVM. Section 4 describes the four garbagecollectors that are available, including one that is new in J2SE 5.0 update 6, and documents the generationalmemory organization they all utilize. For each collector, Section 4 summarizes the types of collection algorithmsused and specifies when it would be appropriate to choose that collector.Section 5 describes a technique new in the J2SE 5.0 release that combines (1) automatic selection of garbagecollector, heap sizes, and HotSpot JVM (client or server) based on the platform and operating system on whichthe application is running, and (2) dynamic garbage collection tuning based on user-specified desired behavior.This technique is referred to as ergonomics.Section 6 provides recommendations for selecting and configuring a garbage collector. It also provides someadvice as to what to do about OutOfMemoryErrors. Section 7 briefly describes some of the tools that can beutilized to evaluate garbage collection performance, and Section 8 lists the most commonly-used command lineoptions that relate to garbage collector selection and behavior. Finally, Section 9 supplies links to more detaileddocumentation for the various topics covered by this paper.2 Explicit vs. Automatic Memory ManagementMemory management is the process of recognizing when allocated objects are no longer needed, deallocating(freeing) the memory used by such objects, and making it available for subsequent allocations. In someprogramming languages, memory management is the programmer’s responsibility. The complexity of that taskleads to many common errors that can cause unexpected or erroneous program behavior and crashes. As aresult, a large proportion of developer time is often spent debugging and trying to correct such errors.One problem that often occurs in programs with explicit memory management is dangling references. It ispossible to deallocate the space used by an object to which some other object still has a reference. If the objectwith that (dangling) reference tries to access the original object, but the space has been reallocated to a newobject, the result is unpredictable and not what was intended.Another common problem with explicit memory management is space leaks. These leaks occur when memory isallocated and no longer referenced but is not released. For example, if you intend to free the space utilized by alinked list but you make the mistake of just deallocating the first element of the list, the remaining list elementsare no longer referenced but they go out of the program’s reach and can neither be used nor recovered. Ifenough leaks occur, they can keep consuming memory until all available memory is exhausted.An alternate approach to memory management that is now commonly utilized, especially by most modernobject-oriented languages, is automatic management by a program called a garbage collector. Automaticmemory management enables increased abstraction of interfaces and more reliable code.4Garbage CollectionSun Microsystems, Inc.Garbage collection avoids the dangling reference problem, because an object that is still referenced somewherewill never be garbage collected and so will not be considered free. Garbage collection also solves the space leakproblem described above since it automatically frees all memory no longer referenced.3 Garbage Collection ConceptsA garbage collector is responsible for• allocating memory• ensuring that any referenced objects remain in memory, and • recovering memory used by objects that are no longer reachable from references in executing code. Objects that are referenced are said to be live. Objects that are no longer referenced are considered dead and aretermed garbage. The process of finding and freeing (also known as reclaiming) the space used by these objectsis known as garbage collection. Garbage collection solves many, but not all, memory allocation problems. You could, for example, create objectsindefinitely and continue referencing them until there is no more memory available. Garbage collection is also acomplex task taking time and resources of its own.The precise algorithm used to organize memory and allocate and deallocate space is handled by the garbagecollector and hidden from the programmer. Space is commonly allocated from a large pool of memory referredto as the heap.The timing of garbage collection is up to the garbage collector. Typically, the entire heap or a subpart of it iscollected either when it fills up or when it reaches a threshold percentage of occupancy.The task of fulfilling an allocation request, which involves finding a block of unused memory of a certain size inthe heap, is a difficult one. The main problem for most dynamic memory allocation algorithms is to avoidfragmentation (see below), while keeping both allocation and deallocation efficient. Desirable Garbage Collector CharacteristicsA garbage collector must be both safe and comprehensive. That is, live data must never be erroneously freed,and garbage should not remain unclaimed for more than a small number of collection cycles.It is also desirable that a garbage collector operate efficiently, without introducing long pauses during which theapplication is not running. However, as with most computer-related systems, there are often trade-offs betweentime, space, and frequency. For example, if a heap size is small, collection will be fast but the heap will fill upmore quickly, thus requiring more frequent collections. Conversely, a large heap will take longer to fill up andthus collections will be less frequent, but they may take longer.Another desirable garbage collector characteristic is the limitation of fragmentation. When the memory forgarbage objects is freed, the free space may appear in small chunks in various areas such that there might notbe enough space in any one contiguous area to be used for allocation of a large object. One approach toeliminating fragmentation is called compaction, discussed among the various garbage collector design choicesbelow.Scalability is also important. Allocation should not become a scalability bottleneck for multithreadedapplications on multiprocessor systems, and collection should also not be such a bottleneck.5Garbage CollectionSun Microsystems, Inc.Design Choices A number of choices must be made when designing or selecting a garbage collection algorithm:• Serial versus ParallelWith serial collection, only one thing happens at a time. For example, even when multiple CPUs areavailable, only one is utilized to perform the collection. When parallel collection is used, the task ofgarbage collection is split into parts and those subparts are executed simultaneously, on differentCPUs. The simultaneous operation enables the collection to be done more quickly, at the expense ofsome additional complexity and potential fragmentation.• Concurrent versus Stop-the-worldWhen stop-the-world garbage collection is performed, execution of the application is completelysuspended during the collection. Alternatively, one or more garbage collection tasks can be executedconcurrently, that is, simultaneously, with the application. Typically, a concurrent garbage collectordoes most of its work concurrently, but may also occasionally have to do a few short stop-the-worldpauses. Stop-the-world garbage collection is simpler than concurrent collection, since the heap isfrozen and objects are not changing during the collection. Its disadvantage is that it may beundesirable for some applications to be paused. Correspondingly, the pause times are shorter whengarbage collection is done concurrently, but the collector must take extra care, as it is operating overobjects that might be updated at the same time by the application. This adds some overhead toconcurrent collectors that affects performance and requires a larger heap size.• Compacting versus Non-compacting versus CopyingAfter a garbage collector has determined which objects in memory are live and which are garbage, itcan compact the memory, moving all the live objects together and completely reclaiming theremaining memory. After compaction, it is easy and fast to allocate a new object at the first freelocation. A simple pointer can be utilized to keep track of the next location available for objectallocation. In contrast with a compacting collector, a non-compacting collector releases the spaceutilized by garbage objects in-place, i.e., it does not move all live objects to create a large reclaimedregion in the same way a compacting collector does. The benefit is faster completion of garbagecollection, but the drawback is potential fragmentation. In general, it is more expensive to allocatefrom a heap with in-place deallocation than from a compacted heap. It may be necessary to search theheap for a contiguous area of memory sufficiently large to accommodate the new object. A thirdalternative is a copying collector, which copies (or evacuates) live objects to a different memory area.The benefit is that the source area can then be considered empty and available for fast and easysubsequent allocations, but the drawback is the additional time required for copying and the extraspace that may be required.Performance MetricsSeveral metrics are utilized to evaluate garbage collector performance, including:• Throughput—the percentage of total time not spent in garbage collection, considered over longperiods of time.• Garbage collection overhead—the inverse of throughput, that is, the percentage of total time spent ingarbage collection.• Pause time—the length of time during which application execution is stopped while garbagecollection is occurring.• Frequency of collection—how often collection occurs, relative to application execution.• Footprint—a measure of size, such as heap size.• Promptness—the time between when an object becomes garbage and when the memory becomesavailable.6Garbage CollectionSun Microsystems, Inc.An interactive application might require low pause times, whereas overall execution time is more important to anon-interactive one. A real-time application would demand small upper bounds on both garbage collectionpauses and the proportion of time spent in the collector in any period. A small footprint might be the mainconcern of an application running in a small personal computer or embedded system.Generational CollectionWhen a technique called generational collection is used, memory is divided into generations, that is, separatepools holding objects of different ages. For example, the most widely-used configuration has two generations:one for young objects and one for old objects.Different algorithms can be used to perform garbage collection in the different generations, each algorithmoptimized based on commonly observed characteristics for that particular generation. Generational garbagecollection exploits the following observations, known as the weak generational hypothesis, regardingapplications written in several programming languages, including the Java programming language:• Most allocated objects are not referenced (considered live) for long, that is, they die young.• Few references from older to younger objects exist.Young generation collections occur relatively frequently and are efficient and fast because the young generationspace is usually small and likely to contain a lot of objects that are no longer referenced.Objects that survive some number of young generation collections are eventually promoted, or tenured, to theold generation. See Figure 1. This generation is typically larger than the young generation and its occupancygrows more slowly. As a result, old generation collections are infrequent, but take significantly longer tocomplete.AllocationYoung GenerationPromotionOld GenerationFigure 1. Generational garbage collectionThe garbage collection algorithm chosen for a young generation typically puts a premium on speed, since younggeneration collections are frequent. On the other hand, the old generation is typically managed by an algorithmthat is more space efficient, because the old generation takes up most of the heap and old generationalgorithms have to work well with low garbage densities. 7Garbage Collectors in the J2SE 5.0 HotSpot JVMSun Microsystems, Inc.4 Garbage Collectors in the J2SE 5.0 HotSpot JVMThe Java HotSpot virtual machine includes four garbage collectors as of J2SE 5.0 update 6. All the collectors aregenerational. This section describes the generations and the types of collections, and discusses why objectallocations are often fast and efficient. It then provides detailed information about each collector.HotSpot GenerationsMemory in the Java HotSpot virtual machine is organized into three generations: a young generation, an oldgeneration, and a permanent generation. Most objects are initially allocated in the young generation. The oldgeneration contains objects that have survived some number of young generation collections, as well as somelarge objects that may be allocated directly in the old generation. The permanent generation holds objects thatthe JVM finds convenient to have the garbage collector manage, such as objects describing classes and methods,as well as the classes and methods themselves.The young generation consists of an area called Eden plus two smaller survivor spaces, as shown in Figure 2.Most objects are initially allocated in Eden. (As mentioned, a few large objects may be allocated directly in theold generation.) The survivor spaces hold objects that have survived at least one young generation collectionand have thus been given additional chances to die before being considered “old enough” to be promoted to theold generation. At any given time, one of the survivor spaces (labeled From in the figure) holds such objects,while the other is empty and remains unused until the next collection. Young GenerationEdenFromToemptySurvivor SpacesFigure 2. Young generation memory areasGarbage Collection TypesWhen the young generation fills up, a young generation collection (sometimes referred to as a minor collection)of just that generation is performed. When the old or permanent generation fills up, what is known as a fullcollection (sometimes referred to as a major collection) is typically done. That is, all generations are collected.Commonly, the young generation is collected first, using the collection algorithm designed specifically for thatgeneration, because it is usually the most efficient algorithm for identifying garbage in the young generation.Then what is referred to below as the old generation collection algorithm for a given collector is run on both theold and permanent generations. If compaction occurs, each generation is compacted separately.Sometimes the old generation is too full to accept all the objects that would be likely to be promoted from theyoung generation to the old generation if the young generation was collected first. In that case, for all but theCMS collector, the young generation collection algorithm is not run. Instead, the old generation collectionalgorithm is used on the entire heap. (The CMS old generation algorithm is a special case because it cannotcollect the young generation.)8Garbage Collectors in the J2SE 5.0 HotSpot JVMSun Microsystems, Inc.Fast AllocationAs you will see from the garbage collector descriptions below, in many cases there are large contiguous blocksof memory available from which to allocate objects. Allocations from such blocks are efficient, using a simplebump-the-pointer technique. That is, the end of the previously allocated object is always kept track of. When anew allocation request needs to be satisfied, all that needs to be done is to check whether the object will fit inthe remaining part of the generation and, if so, to update the pointer and initialize the object. For multithreaded applications, allocation operations need to be multithread-safe. If global locks were used toensure this, then allocation into a generation would become a bottleneck and degrade performance. Instead,the HotSpot JVM has adopted a technique called Thread-Local Allocation Buffers (TLABs). This improvesmultithreaded allocation throughput by giving each thread its own buffer (i.e., a small portion of thegeneration) from which to allocate. Since only one thread can be allocating into each TLAB, allocation can takeplace quickly by utilizing the bump-the-pointer technique, without requiring any locking. Only infrequently,when a thread fills up its TLAB and needs to get a new one, must synchronization be utilized. Several techniquesto minimize space wastage due to the use of TLABs are employed. For example, TLABs are sized by the allocatorto waste less than 1% of Eden, on average. The combination of the use of TLABs and linear allocations using thebump-the-pointer technique enables each allocation to be efficient, only requiring around 10 native instructions.Serial CollectorWith the serial collector, both young and old collections are done serially (using a single CPU), in a stop-the-world fashion. That is, application execution is halted while collection is taking place.Young Generation Collection Using the Serial CollectorFigure 3 illustrates the operation of a young generation collection using the serial collector. The liveobjects in Eden are copied to the initially empty survivor space, labeled To in the figure, except for onesthat are too large to fit comfortably in the To space. Such objects are directly copied to the oldgeneration. The live objects in the occupied survivor space (labeled From) that are still relatively youngare also copied to the other survivor space, while objects that are relatively old are copied to the oldgeneration. Note: If the To space becomes full, the live objects from Eden or From that have not beencopied to it are tenured, regardless of how many young generation collections they have survived. Anyobjects remaining in Eden or the From space after live objects have been copied are, by definition, notlive, and they do not need to be examined. (These garbage objects are marked with an X in the figure,though in fact the collector does not examine or mark these objects.)Young GenerationEdenFromToemptySurvivor SpacesOld GenerationFigure 3. Serial young generation collectionAfter a young generation collection is complete, both Eden and the formerly occupied survivor space areempty and only the formerly empty survivor space contains live objects. At this point, the survivorspaces swap roles. See Figure 4.9Garbage Collectors in the J2SE 5.0 HotSpot JVMSun Microsystems, Inc.Young GenerationemptyEdenToFromempty Survivor SpacesOld GenerationFigure 4. After a young generation collectionOld Generation Collection Using the Serial CollectorWith the serial collector, the old and permanent generations are collected via a mark-sweep-compactcollection algorithm. In the mark phase, the collector identifies which objects are still live. The sweepphase “sweeps” over the generations, identifying garbage. The collector then performs slidingcompaction, sliding the live objects towards the beginning of the old generation space (and similarly forthe permanent generation), leaving any free space in a single contiguous chunk at the opposite end. SeeFigure 5. The compaction allows any future allocations into the old or permanent generation to use thefast, bump-the-pointer technique.a) Start of Compactionb) End of CompactionFigure 5. Compaction of the old generationWhen to Use the Serial CollectorThe serial collector is the collector of choice for most applications that are run on client-style machinesand that do not have a requirement for low pause times. On today’s hardware, the serial collector canefficiently manage a lot of nontrivial applications with 64MB heaps and relatively short worst-casepauses of less than half a second for full collections.Serial Collector SelectionIn the J2SE 5.0 release, the serial collector is automatically chosen as the default garbage collector onmachines that are not server-class machines, as described in Section 5. On other machines, the serialcollector can be explicitly requested by using the -XX:+UseSerialGC command line option.Parallel CollectorThese days, many Java applications run on machines with a lot of physical memory and multiple CPUs. Theparallel collector, also known as the throughput collector, was developed in order to take advantage of availableCPUs rather than leaving most of them idle while only one does garbage collection work. Young Generation Collection Using the Parallel CollectorThe parallel collector uses a parallel version of the young generation collection algorithm utilized by theserial collector. It is still a stop-the-world and copying collector, but performing the young generation10Garbage Collectors in the J2SE 5.0 HotSpot JVMSun Microsystems, Inc.collection in parallel, using many CPUs, decreases garbage collection overhead and hence increasesapplication throughput. Figure 6 illustrates the differences between the serial collector and the parallelcollector for the young generation.Serial CollectorParallel CollectorStop-the-world pauseFigure 6. Comparison between serial and parallel young generation collectionOld Generation Collection Using the Parallel CollectorOld generation garbage collection for the parallel collector is done using the same serial mark-sweep-compact collection algorithm as the serial collector.When to Use the Parallel CollectorApplications that can benefit from the parallel collector are those that run on machines with more thanone CPU and do not have pause time constraints, since infrequent, but potentially long, old generationcollections will still occur. Examples of applications for which the parallel collector is often appropriateinclude those that do batch processing, billing, payroll, scientific computing, and so on.You may want to consider choosing the parallel compacting collector (described next) over the parallelcollector, since the former performs parallel collections of all generations, not just the younggeneration.Parallel Collector SelectionIn the J2SE 5.0 release, the parallel collector is automatically chosen as the default garbage collector onserver-class machines (defined in Section 5). On other machines, the parallel collector can be explicitlyrequested by using the -XX:+UseParallelGC command line option.Parallel Compacting CollectorThe parallel compacting collector was introduced in J2SE 5.0 update 6. The difference between it and the parallelcollector is that it uses a new algorithm for old generation garbage collection. Note: Eventually, the parallelcompacting collector will replace the parallel collector.Young Generation Collection Using the Parallel Compacting CollectorYoung generation garbage collection for the parallel compacting collector is done using the samealgorithm as that for young generation collection using the parallel collector.Old Generation Collection Using the Parallel Compacting CollectorWith the parallel compacting collector, the old and permanent generations are collected in a stop-the-world, mostly parallel fashion with sliding compaction. The collector utilizes three phases. First, eachgeneration is logically divided into fixed-sized regions. In the marking phase, the initial set of live objectsdirectly reachable from the application code is divided among garbage collection threads, and then alllive objects are marked in parallel. As an object is identified as live, the data for the region it is in isupdated with information about the size and location of the object.

Download
Memory Management in the Java HotSpot Virtual Machine

 

 

Your download will begin in a moment.
If it doesn't, click here to try again.

Share Memory Management in the Java HotSpot Virtual Machine to:

Insert your wordpress URL:

example:

http://myblog.wordpress.com/
or
http://myblog.com/

Share Memory Management in the Java HotSpot Virtual Machine as:

From:

To:

Share Memory Management in the Java HotSpot Virtual Machine.

Enter two words as shown below. If you cannot read the words, click the refresh icon.

loading

Share Memory Management in the Java HotSpot Virtual Machine as:

Copy html code above and paste to your web page.

loading