Memory and many tiny objects

Question

I have a tight loop in which I'm calling a complex function to return data many thousands of times a second. Ideally, I'd like to do something like this:
class Data
     final int x;
     final int y;
     public Data(int x, int y)
          this.x = x;
          this.y = y;
class Inner
     public Data calculate()
          return new Data(calcX(), calcY());
class Outer
     Inner inner;
     public void doWork()
          Data data = inner.calculate();
          //Do something with Data
}However, I quickly dirty all my memory and the garbage collector is being called every few seconds. A way around this is to restructure the code:
class Data
     int x;
     int y;
     public Data()
class Inner
     public void calculate(Data value)
          value.x = calcX();
          value.y = calcY();
class Outer
     Inner inner;
     Data data = new Data();
     public void doWork()
          inner.calculate(data);
          //Do something with Data
}Now the garbage collector is no longer being hammered - however, I've also lost the immutability of Data and Outer is becoming cluttered with extra fields that do nothing but hold onto chunks of memory. I'm wishing there was some way I could do a C style allocation of an object on the stack.
I'm finding that I'm making the above compromise a lot to keep the garbage collector happy. Is there a better way to go about this?

Answer 1

Thanks for the link. I'll read through it.
I've read a couple of articles on HotSpot memory allocation. The way I understand it, Java slices off a chunk of the heap each time you need an object. Then when it's all gone, it looks for all memory no longer in use and bundles it all together to create a new heap. So you get really fast allocation and deallocation times, but a slow garbage collection.
I am noticing performance problems. Before, every few seconds my program would freeze while garbage collection ran. The docs hint that HotSpot should be doing some magic behind the scenes to make this unnecessary, but it's not working in practice.