What are generations in Garbage Collection
terminology? What is its relevance?
Garbage Collectors make assumptions about how our application runs. Most
common assumption is that an object is most likely to die shortly after
it was created: called infant mortality. This assumes that an object
that has been around for a while, will likely stay around for a while.
GC organizes objects into generations (young, tenured, and perm). This
tells that if an object lives for more than certain period of time it is
moved from one generation to another generations( say from young ->
tenured -> permanent). Hence GC will be run more frequently at the young
generations and rarely at permanent generations. This reduces the
overhead on GC and gives faster response time.
What is a Throughput Collector?
The throughput collector is a generational collector similar to the
default collector but with multiple threads used to do the minor
collection. The major collections are essentially the same as with the
default collector. By default on a host with N CPUs, the throughput
collector uses N garbage collector threads in the collection. The number
of garbage collector threads can be controlled with a command line
When to Use the Throughput Collector?
Use the throughput collector when you want to improve the performance of
your application with larger numbers of processors. In the default
collector garbage collection is done by one thread, and therefore
garbage collection adds to the serial execution time of the application.
The throughput collector uses multiple threads to execute a minor
collection and so reduces the serial execution time of the application.
A typical situation is one in which the application has a large number
of threads allocating objects. In such an application it is often the
case that a large young generation is needed
What is Aggressive Heap?
The -XX:+AggressiveHeap option inspects the machine resources (size of
memory and number of processors) and attempts to set various parameters
to be optimal for long-running, memory allocation-intensive jobs. It was
originally intended for machines with large amounts of memory and a
large number of CPUs, but in the J2SE platform, version 1.4.1 and later
it has shown itself to be useful even on four processor machines. With
this option the throughput collector (-XX:+UseParallelGC) is used along
with adaptive sizing (-XX:+UseAdaptiveSizePolicy). The physical memory
on the machines must be at least 256MB before Aggressive Heap can be
What is a Concurrent Low Pause Collector?
The concurrent low pause collector is a generational collector similar
to the default collector. The tenured generation is collected
concurrently with this collector. This collector attempts to reduce the
pause times needed to collect the tenured generation. It uses a separate
garbage collector thread to do parts of the major collection
concurrently with the applications threads. The concurrent collector is
enabled with the command line option -XX:+UseConcMarkSweepGC. For each
major collection the concurrent collector will pause all the application
threads for a brief period at the beginning of the collection and toward
the middle of the collection. The second pause tends to be the longer of
the two pauses and multiple threads are used to do the collection work
during that pause. The remainder of the collection is done with a
garbage collector thread that runs concurrently with the application.
The minor collections are done in a manner similar to the default
collector, and multiple threads can optionally be used to do the minor
When to Use the Concurrent Low Pause Collector?
Use the concurrent low pause collector if your application would benefit
from shorter garbage collector pauses and can afford to share processor
resources with the garbage collector when the application is running.
Typically applications which have a relatively large set of long-lived
data (a large tenured generation), and run on machines with two or more
processors tend to benefit from the use of this collector. However, this
collector should be considered for any application with a low pause time
requirement. Optimal results have been observed for interactive
applications with tenured generations of a modest size on a single
What is Incremental Low Pause Collector?
The incremental low pause collector is a generational collector similar
to the default collector. The minor collections are done with the same
young generation collector as the default collector. Do not use either -XX:+UseParallelGC
or -XX:+UseParNewGC with this collector. The major collections are done
incrementally on the tenured generation. This collector (also known as
the train collector) collects portions of the tenured generation at each
minor collection. The goal of the incremental collector is to avoid very
long major collection pauses by doing portions of the major collection
work at each minor collection. The incremental collector will sometimes
find that a non-incremental major collection (as is done in the default
collector) is required in order to avoid running out of memory.
When to Use the Incremental Low Pause Collector?
Use the incremental low pause collector when your application can afford
to trade longer and more frequent young generation garbage collection
pauses for shorter tenured generation pauses. A typical situation is one
in which a larger tenured generation is required (lots of long-lived
objects), a smaller young generation will suffice (most objects are
short-lived and don't survive the young generation collection), and only
a single processor is available.
How do you enable the concurrent garbage collector on Sun's JVM?
-Xconcgc options allows us to use concurrent garbage collector
(1.2.2_07+)we can also use -XX:+UseConcMarkSweepGC which is available
beginning with J2SE 1.4.1.
What is a platform?
A platform is the hardware or software environment in which a program
runs. Most platforms can be described as a combination of the operating
system and hardware, like Windows 2000 and XP, Linux, Solaris, and MacOS.
What is transient variable?
Transient variable can't be serialize. For example if a variable is
declared as transient in a Serializable class and the class is written
to an ObjectStream, the value of the variable can't be written to the
stream instead when the class is retrieved from the ObjectStream the
value of the variable becomes null.
Page Numbers :