java how expensive is a method call

Question

I'm a beginner and I've always read that it's bad to repeat code. However, it seems that in order to not do so, you would have to have extra method calls usually. Let's say I have the following class

public class BinarySearchTree<E extends Comparable<E>>{
    private BinaryTree<E> root;
    private final BinaryTree<E> EMPTY = new BinaryTree<E>();
    private int count;
    private Comparator<E> ordering;

    public BinarySearchTree(Comparator<E> order){
        ordering = order;
        clear();
    }

    public void clear(){
        root = EMPTY;
        count = 0;
    }
}

Would it be more optimal for me to just copy and paste the two lines in my clear() method into the constructor instead of calling the actual method? If so how much of a difference does it make? What if my constructor made 10 method calls with each one simply setting an instance variable to a value? What's the best programming practice?

Excited

But wait, if you invoke the method now, we'll throw in a SECOND method call, absolutely free! Pay only shipping and handling! Seriously, though. There's overhead in method calls, just as there's overhead in having more code to load. At some point one becomes more expensive than the other. The only way to tell is by benchmarking your code. – Sphacelus

premature optimization quotes in 3 ... 2 ... 1 – Interglacial

I don't see the reason for the downvote on this - the guy is asking a perfectly legitimate question. It might be an obvious answer to some but that doesn't make it a bad question! – Tornado

And if you invoke a THIRD method, we must just give you a GARBAGE COLLECTOR absolutely free. LOL – Squamosal

Indeed, it's a very legitimate question, only reason for a down vote might be if there is an exact duplicate. – Galenism

yea sorry if it's obvious, but I'm learning by myself, and I've only been at it for a few months. Some things I've seen in sample code online I've found to be not good practice so I just want to double check. – Excited

@Excited Good call, very wise to check things you find in such places online! – Tornado

There are additional concerns because you are asking about a constructor. – Stomachache

All these comments, not a single number or benchmark. I think all these "experts" are blowing smoke. Maybe this will help: plumbr.eu/blog/performance-blog/… – Stoke

Answer 1

Would it be more optimal for me to just copy and paste the two lines in my clear() method into the constructor instead of calling the actual method?

The compiler can perform that optimization. And so can the JVM. The terminology used by compiler writer and JVM authors is "inline expansion".

If so how much of a difference does it make?

Measure it. Often, you'll find that it makes no difference. And if you believe that this is a performance hotspot, you're looking in the wrong place; that's why you'll need to measure it.

What if my constructor made 10 method calls with each one simply setting an instance variable to a value?

Again, that depends on the generated bytecode and any runtime optimizations performed by the Java Virtual machine. If the compiler/JVM can inline the method calls, it will perform the optimization to avoid the overhead of creating new stack frames at runtime.

What's the best programming practice?

Avoiding premature optimization. The best practice is to write readable and well-designed code, and then optimize for the performance hotspots in your application.

Barhorst

what is a good way to benchmark? is there some software I can download or do you mean just use System.nanoTime() at the start and end and print the difference? – Excited

System.nanoTime() or System.currentTimeMillis is a poor way of doing profiling. You can get a list of profilers from the answer at this Stackoverflow question. I would recommend VisualVM, for it comes with the JDK now. – Barhorst

@jhlu87: I think you'd find it very difficult to get an accurate estimate of the overhead of a method call. Microbenchmarking is very hard to get right and even then generally isn't very useful in the grand scheme of things. Read this. – Desalinate

@VineetReynolds the linked question is dead. – Davisdavison

Answer 2

What everyone else has said about optimization is absolutely true.

There is no reason from a performance point of view to inline the method. If it's a performance issue, the JIT in your JVM will inline it. In java, method calls are so close to free that it isn't worth thinking about it.

That being said, there's a different issue here. Namely, it is bad programming practice to call an overrideable method (i.e., one that is not final, static, or private) from the constructor. (Effective Java, 2nd Ed., p. 89 in the item titled "Design and document for inheritance or else prohibit it")

What happens if someone adds a subclass of BinarySearchTree called LoggingBinarySearchTree that overrides all public methods with code like:

public void clear(){
  this.callLog.addCall("clear");
  super.clear();
}

Then the LoggingBinarySearchTree will never be constructable! The issue is that this.callLog will be null when the BinarySearchTree constructor is running, but the clear that gets called is the overridden one, and you'll get a NullPointerException.

Note that Java and C++ differ here: in C++, a superclass constructor that calls a virtual method ends up calling the one defined in the superclass, not the overridden one. People switching between the two languages sometimes forget this.

Given that, I think it's probably cleaner in your case to inline the clear method when called from the constructor, but in general in Java you should go ahead and make all the method calls you want.

Lontson

I don't think he was asking for coding style tips but rather knowing if a method call is expensive or not – Piebald

He explicity asked "What's the best programming practice?" - as a matter of best practices, this is perfectly relevant. – Lontson

If you take only the last sentence, you completely lose the context of this question. He wants to know if it is expensive to breakdown you big method into many smaller methods, because a method call has a price. Adding an answer that describes an anti pattern for calling a non final method from a constructor doesn't count as answer to his question as a whole. Oh and check out the title of the question " how expensive is a method call" – Piebald

Answer 3

I would definitely leave it as is. What if you change the clear() logic? It would be impractical to find all the places where you copied the 2 lines of code.

Nuclease

Answer 4

Generally speaking (and as a beginner this means always!) you should never make micro-optimisations like the one you're considering. Always favour readability of code over things like this.

Why? Because the compiler / hotspot will make these sorts of optimisations for you on the fly, and many, many more. If anything, when you try and make optimisations along these sorts of lines (though not in this case) you'll probably make things slower. Hotspot understands common programming idioms, if you try and do that optimisation yourself it probably won't understand what you're trying to do so it won't be able to optimise it.

There's also a much greater maintenance cost. If you start repeating code then it's going to be much more effort to maintain, which will probably be a lot more hassle than you might think!

As an aside, you may get to some points in your coding life where you do need to make low level optimisations - but if you hit those points, you'll definitely, definitely know when the time comes. And if you don't, you can always go back and optimise later if you need to.

Tornado

Answer 5

The cost of a method call is the creation (and disposal) of a stack frame and some extra byte code expressions if you need to pass values to the method.

Edin

Answer 6

The best practice is to measure twice and cut once.

Once you've wasted time optimization, you can never get it back again! (So measure it first and ask yourself if it's worth optimisation. How much actual time will you save?)

In this case, the Java VM is probably already doing the optimization you are talking about.

Galenism

Answer 7

The pattern that I follow, is whether or not this method in question would satisfy one of the following:

• Would it be helpful to have this method available outside this class?
• Would it be helpful to have this method available in other methods?
• Would it be frustrating to rewrite this every time i needed it?
• Could the versatility of the method be increased with the use of a few parameters?

If any of the above are true, it should be wrapped up in it's own method.

Ceraceous

It's easier not to ask these questions and just put the darn code in it's own method already! – Galenism

The asker is curious what granularity of his method calls should be. There is no need to create a method to increment an integer if you can just use i++; – Ceraceous

Actually there is a lot of value in creating a method even if there is not a chance for it to ever be reused. Just giving a name to a block of code and making the overall structure appear is a great benefit in itself. – Suprematism

Answer 8

Keep the clear() method when it helps readability. Having unmaintainable code is more expensive.

Stringendo

Answer 9

Optimizing compilers usually do a pretty good job of removing the redundancy from these "extra" operations; in many instances, the difference between "optimized" code and code simply written the way you want, and run through an optimizing compiler is none; that is to say, the optimizing compiler usually does just as good a job as you'd do, and it does it without causing any degradation of the source code. In fact, many times, "hand-optimized" code ends up being LESS efficient, because the compiler considers many things when doing the optimization. Leave your code in a readable format, and don't worry about optimization until a later time.

"Premature optimization is the root of all evil." - Donald Knuth

Phrasal

Answer 10

I wouldn't worry about method call as much but the logic of the method. If it was critical systems, and the system needed to "be fast" then, I would look at optimising codes that takes long to execute.

Squamosal

Answer 11

Given the memory of modern computers this is very inexpensive. Its always better to break your code up into methods so someone can quickly read whats going on. It will also help with narrowing down errors in the code if the error is restricted to a single method with a body of a few lines.

Mordy

Answer 12

As others have said, the cost of the method call is trivial-to-nada, as the compiler will optimize it for you.

That said, there are dangers in making method calls to instance methods from a constructor. You run the risk of later updating the instance method so that it may try to use an instance variable that has not been initiated yet by the constructor. That is, you don't necessarily want to separate out the construction activities from the constructor.

Another question--your clear() method sets the root to EMPTY, which is initialized when the object is created. If you then add nodes to EMPTY, and then call clear(), you won't be resetting the root node. Is this the behavior you want?

Fostoria