1

I had a class like this : 

class Test
{
    public static test getInstance()
    {
        return new test()
    }

    public void firstMethod()
    {
        //do something
    }
    public void secondMethod()
    {
        //do something
    }
    public void thirdMethod()
    {
        //do something
    }
}

in the another class if we calling Test.getInstance().methodName() several times with different method, what happening? Which one will be faster and using low memory in following codes?

Test.getInstance().firstMethod()
Test.getInstance().secondMethod()
Test.getInstance().thirdMethod()

or 

Test test = Test.getInstance();
test.firstMethod();
test.secondMethod();
test.thirdMethod();
Improve this question
7
  • 4
    @GáborBakos prove it Commented Nov 19, 2014 at 21:31
  • 1
    I don't think it will be any - It should be the same - the reason is that compiler optimises it anyway. at the end of the day, everything is in the heap space for Java and garbage collection chucks things out which you don't use up. The only thing that looks different in the first instance is the reference count for Test.getInstance().firstMethod()...etc. and just one test object. I think someone will surely put it in his/her answer to explain. Commented Nov 19, 2014 at 21:31
  • 1
    I think the second one's faster because the first one creates a new instance for each method call, right? Unless it gets optimized. Commented Nov 19, 2014 at 21:33
  • When you have a getInstance() method, it usually implies that you use the Singleton pattern, which means only the first call will create a new Test and all subsequent calls return that one instance. When you have a factory method which is supposed to return a new instance whenever it is called, call it create() or makeTest(). Also, when the methods of your class don't use any variables, you should make them static and call them statically with Test.methodName. Commented Nov 19, 2014 at 21:33
  • 1
    See my comment below, @Chris. All objects are at least an instance of Object, which does have to allocate memory. That does take time. Commented Nov 19, 2014 at 21:36

3 Answers 3

Reset to default
3 
Test.getInstance().firstMethod()
Test.getInstance().secondMethod()
Test.getInstance().thirdMethod()

This will create three different instances of the Test class and call a method on each.

Test test = Test.getInstance();
test.firstMethod();
test.secondMethod();
test.thirdMethod();

Will create only one instance and invoke the three methods on that instance.

So it's a completely different behavior to begin with. Obviously, since the first creates three objects, then it should take more heap space.

If you're intending to implement a singleton class, however, both are equivalent.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

And since every object is an Object, the JIT might not be able to completely optimize the calls to new away. So memory has to be allocated (takes a bit of time) and then garbage collected too (takes longer, but happens over time).
You did not answered to my question,i just want to know,witch one using low memory and faster than another?
@Chris The first code creates three objects while the second creates only one. I think it should be obvious from here.
in the first example the objects where are stored?
They may not be stored in variables, but they take up memory until they are garbage collected. The same can be said about the second code.
1

Every time you call getInstance the system has to allocate heap storage for a Test object and initialize it.

Furthermore, somewhere down the line the system will have to garbage-collect all those extra Test objects. With a copying collector the overhead per object is minimal, but there is some -- if for no other reason than you're causing GC to occur more often.

Improve this answer

Comments

0 
class Test 
{
    public static Test getInstance() 
    {
        return new Test();
    }

    public void firstMethod() 
    {
        // do something
    }

    public void secondMethod() 
    {
        // do something
    }

    public void thirdMethod() 
    {
        // do something
    }
}

public class Blah 
{
    public static void main(String[] args) 
    {
        int i = 0;
        long start = System.nanoTime();
        Test t = new Test();
        for (; i < 100000; i++) 
        {
            t.firstMethod();
        }
        long stop = System.nanoTime();
        System.out.println(stop - start);
        i = 0;
        start = System.nanoTime();
        for (; i < 100000; i++) 
        {
            Test.getInstance().firstMethod();
        }
        stop = System.nanoTime();
        System.out.println(stop - start);

    }
}

output:

~3486938
~4894574

Creating single instance with new Test() proved to be consistently faster by about 30%.

Memory calculations are harder due to disability to do it in one run. However if we run only the first loop (changing what's inside) and use:

Runtime runtime = Runtime.getRuntime();
long memory = runtime.totalMemory() - runtime.freeMemory();

just before printing. In two separate runs we can determine the difference: ~671200 or ~1342472 (seemed to change between runs rather randomly with no clear influence on runtime) for new Test() and ~2389288 (no big differences this time) for getInstance() in 100000 iterations. Again clear victory to single instance

Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.