Java 7 for Absolute Beginners

CHAPTER 13 ■ GARBAGE COLLECTION

public static ArrayList<Object> referenceList;

public static void main(String[] args) {

referenceList = new ArrayList<Object>();

}

}

As the comment within the class says, the referenceList object will have a reference for as long as the

program runs. So far, so good, but how do we add to it? The trick to that is to have any class we need to

keep around to add itself to the list, as shown in the next code listing:

Listing 13-7. Class that Adds Itself to a Reference List

package com.bryantcs.examples.referenceList;

public class ClassToList {

public ClassToList() {

ReferenceProgram.referenceList.add(this);

}

}

Since ReferenceProgram.referenceList is static, it is a class variable, which means there's only one

of them, regardless of the number of instances we may make of the ReferenceProgram class. (Of course,

in this very simple example, we wouldn't make more than one instance of the ReferenceProgram class

anyway.) As a result, we can add to that single list from anywhere within the program. Thus, we have a

handy mechanism for ensuring that a reference to any given class always exists and, consequently, that

any instance of this class will never be garbage collected.

While these techniques work, you should avoid overusing both the singleton pattern and the

reference list pattern. If you prevent the garbage collector from removing many objects, your program

performs that much more slowly.

A New Garbage Collector

As we saw earlier in the chapter, Java 7 includes a new garbage collector, called G1. G1 is a concurrent

garbage collector, meaning that it uses multiple processors (if available) at the same time. Also, as we

read earlier in the chapter, the G1 collector's “garbage first” algorithm offers better performance than

other collectors, regardless of the number of processors. For a computer with just one processor (or a

shared computer that makes only one processor available to the JVM), G1 should offer some

improvement over any other garbage collector (though the nature of the application may limit the

improvement). If G1 can get access to at least two processors, the improvement in performance should

be even better. Given that most modern computers have multiple processors and modern server-class

computers often have numerous processors, G1 may provide a sizable performance boost for some

applications. That's going to result in games that play more smoothly, web applications that return web

pages more quickly, and all the other good things that come with higher-performance applications.