Slow Program depending on Sourcecode position???

Question

Hi all,
while testing with Generics I get a litle Problem.
Here is my test Class:
public class GenericTest {
  private String s = "x";
  private long z = 500000000;
  public static void main(String[] args) {
    new GenericTest();
  public GenericTest() {
    test();
  public void test() {
     * Block non Generic
      System.out.println("Start non Generic");
      long t = System.currentTimeMillis();
      String ls = null;
      StringBox sb = new StringBox();
      for (int i = 0; i < z; i++) {
        sb.setValue(s);
        ls = sb.getValue();
      System.out.println("non Generic " + (System.currentTimeMillis() - t));
     * Block Generic
      System.out.println("Start Generic");
      long t = System.currentTimeMillis();
      String ls = null;
      Box<String> sb = new Box<String>();
      for (int i = 0; i < z; i++) {
        sb.setValue(s);
        ls = sb.getValue();
      System.out.println("Generic " + (System.currentTimeMillis() - t));
  class Box<T> {
    private T value;
    public T getValue() {
      return value;
    public void setValue(T value) {
      this.value = value;
  class StringBox {
    private String value;
    public String getValue() {
      return value;
    public void setValue(String value) {
      this.value = value;
}As you can see there are two Blocks, each one using a Class. On with a generic Desing, the other one with a concrete Type.
Both do the same.
The strange thing about it is,      regardless of which one is first in the Sourcecode, runs about 4 times faster then the second!
If the Program runs like posted, the non-Generic-Block needs about 3 sec., and the Generic-Block about 11sec.
If you change the order of the Blocks, the non-Generic-Block needs about 10 sec., and the Generic-Block about 3.5 sec.
When you put the Blocks in separate Methods they are both running fast.
Can someone please explain this to me?
Thx.
Alex
PS. Tested on Pentium 2.8Ghz and 3.2 GHz, Windows, Java 1.5.06 and 1.5.09.

Answer 1

Skimming over the source code, the garbage collector was also my first guess. It would surprise me if JIT optimization is responsible for the observed behaviour (e.g., why is the second block slower than the first one?). It's 4x difference (about 7 seconds!).
But when looking more closely, I noticed that there is actually neither object creation nor does any object become unreachable inside the loop ("dereferencing" usually has a different meaning, http://en.wikipedia.org/wiki/Dereference) -- it's always the same two instances: String s and the respective Box sb. Well, there is some implicit object creation of StringBuffer during println, but that's outside of the loop... Maybe you can vary the loop count or put like two more loops in each method and see what happens; I have no experience with analyzing GC-related stuff, though...
And as stated above, generics belong to the Java language, not the bytecode language that is executed by the JVM. When you look at the generated bytecode (with javap -c or jclasslib), you can see that a CHECKCAST Ljava/lang/String; bytecode instruction is inserted after the invocation of Box<String>.getValue(), while StringBox.getValue() already returns an object of type String (saving the cast). That is, in bytecode, your Box<String>.getValue() is declared like: Object getValue(). The generics information is included in the .class file, but is only relevant at compile time.