Java Garbage Collection – Which Memory Part is Used?

garbage-collectionjava

I understand the Heap memory divisions such as Young, tenured and Perm Gen.
But I'm just curious from where is the memory used for performing the Garbage Collector itself? Is it from any of these memory spaces or in the thread stacks ?

Best Answer

The answer depends on what you mean by "the memory used for performing the Garbage Collect[ion]" ... and what garbage collector you are talking about.

The general answer is that different garbage collection algorithms use space differently. This is a very high level / simplified summary:

Just about all garbage collectors make use of one or more "mark" bits in each object's header to record that the object has been processed by the GC.
Copying collectors work by copying live objects from a "from" space to a "to" space, and in the simple case don't need any extra space.
Mark / sweep collectors work by recursively walking the graph of "reachable" objects. The recursion can be done explicitly (which requires a separate stack), or by means of a clever pointer-reversal trick (look up Cheney's algorithm).
Concurrent collectors typically require extra memory to track objects that get mutated while the garbage collector is running.

There are whole books on the topic of garbage collection. If you want to really understand how garbage collectors work under the hood, you've got a lot of reading to do.

In general, any additional memory that the GC needs to do its job will typically be allocated outside of the live heap spaces. Thread stack memory is not used ... apart from the thread stack for the garbage collection thread or threads themselves.

Your mention of "young", "tenured" and "permgen" suggests that you are talking about classical Java GCs. These are generational collectors, which is a subtype of copying collectors.

Related Solutions

Stack and Heap Memory Management in Java

The basic difference between stack and heap is the life cycle of the values.

Stack values only exist within the scope of the function they are created in. Once it returns, they are discarded.
Heap values however exist on the heap. They are created at some point in time, and destructed at another (either by GC or manually, depending on the language/runtime).

Now Java only stores primitives on the stack. This keeps the stack small and helps keeping individual stack frames small, thus allowing more nested calls.
Objects are created on the heap, and only references (which in turn are primitives) are passed around on the stack.

So if you create an object, it is put on the heap, with all the variables that belong to it, so that it can persist after the function call returns.

Memory Allocation – Static vs. Dynamic Memory Allocation in Java

If the differences of two approaches are neither significant in runtime nor in performance (and significant means: from a users point of view, not from an academic point of view), then choose the approach which is easier to implement and to maintain.

Actually, seeing only that small part of your application I cannot tell you which of those two approaches is easier to handle at the long term, but the first impression is that "Option 1" is not just faster, but also seems to need less code (at a first glance). The questions you should ask yourself before making the final decision here are:

does your memory extrapolation stick valid for the next months (or years) when the program runs in production?
does the list of categories / questions never change during the time your programs runs? (if it can change, there will be obviously a need to reload that objects from somewhere at some point in time)
what other operations (besides from getRandom) working with collection will be needed in your program? Are those operations easier to be implemented when you preload everything?

Furthermore, providing an accessor getCollection may be good idea, then you can hide the loading / reloading / lazy loading in the implementation of that accessor and change it later, when needed. So make it

    public Question getRandom() {
        return getCollection().getRandomQuestion();
    }

then you can change your initial decision later more easily.

Best Answer

Related Solutions

Stack and Heap Memory Management in Java

Memory Allocation – Static vs. Dynamic Memory Allocation in Java

Related Topic