Is this the best approach to reduce the memory ??

Question

Hi -
I have been given a task to reduce the HEAP memory so that the system can support more number of users. I have used various suggestions given in this forum to find out the size of the object in memory. I have reached to a point that where i think i got an approx size of the object in memory.(not 100%)
I basically have some objects of some other class which are created when this object is created . The intent was to initialize the nested objects once and use them in the main object. I saw some significant difference reduction in size of the object when i create these objects local to the methods which use it.
Before moving the objects to method level
Class A {
    Object b = new Object();
    Object c = new Object();
    Object d = new Object();
     public void method1 () {
         b.someMethod();
     public void method2 () {
         b.someMethod();
     public void method3 () {
         c.someMethod();
     public void method4 () {
         c.someMethod();
     public void method5 () {
         d.someMethod();
     public void method6 () {
         d.someMethod();
After moving the objects to method level
Class A {
     public void method1 () {
       Object b = new Object();
         b.someMethod();
     public void method2 () {
        Object b = new Object();
         b.someMethod();
     public void method3 () {
       Object c = new Object();
         c.someMethod();
     public void method4 () {
      Object c = new Object();
         c.someMethod();
     public void method5 () {
        Object d = new Object();
         d.someMethod();
     public void method6 () {
        Object d = new Object();
         d.someMethod();
}Note : This object remains in the http session atleast 2 hrs. I cannot change the session time out.
Is this the better approach to reduce the heap size? What are the side effects of creating all objects in the local methods which will be on stack?
Thanks in advance

Answer 1

The point is not that the objects are on the stack - they aren't, all objects are in heap, but that they have a much shorter life. They'll become unreachable as soon as the method exits, rather than surviving until the session times out. And the garbage collector will probably recycle them pretty promptly, because they remain in "Eden space".
(In future versions of the JVM Sun is hoping to use "escape analysis" to reclaim such objects even faster).
Of course some objects might have a significant creation overhead, in which case you might want to consider creating some kind of pool of them from which one could get borrowed for the duration of the call. With simple objects, though, the overheads of pooling are likely to be higher.
Are these objects modified during use? If not then you might simply be able to create one instance of each for the whole application, and simply change the fields in the original class to static. The decision depends on thread safety.