Java Static/Instance method optimization

Question

In Java are unmodified method variables, that lack the final, qualifier re-initialized each time in a

static method
instance method

If the answer to 1. or 2., (or both) would the final qualifier allow Java to perform an optimization and store the method variable only once?

If the answer depends on the type of the variable, which type of variables are optimized/unoptimized? For instance, is String, int optimized while Map not optimized?

For comparison, Java would only store a static class variable such as

private static final String foo = "Teenage Mutant Ninja Turtle";

once. To clarify: the question is whether or not

1:

static SomeReturnValueOrVoid SomeMethod() {
    // 1.a Not modified, is this reinitialized each method call?
    String foo = "Teenage Mutant Ninja Turtle";

    // 1.b Marked final, is this reinitialized each method call?
    final String bar = "Teenage Mutant Hero Turtle"; 
}

2:

SomeReturnValueOrVoid SomeMethod() { // not static
    // 2.a Not modified, is this reinitialized each method call?
    String foo = "Teenage Mutant Ninja Turtle";

    // 2.b Marked final, is this reinitialized each method call?
    final String bar = "Teenage Mutant Hero Turtle"; 
}

is equivalent to

3:

class SomeClass {
    static final String foo = "Teenage Mutant Ninja Turtle";

    SomeReturnValueOrVoid SomeMethod() {
        // Uses foo
    }

    static SomeReturnValueOrVoid SomeMethod() {
        // Uses foo
    }

    ...
}

And other types than `String` such as `Map`, how are they handled in this context? — Filip Allberg, May 11 '16 at 08:34
if you create a new map inside a method, no matter is it final or not, it would be created every time. — AdamSkywalker, May 11 '16 at 08:35
@FilipAllberg I recommend going through the [language basics](https://docs.oracle.com/javase/tutorial/). — Kayaman, May 11 '16 at 08:41

score 3 · Accepted Answer · edited May 23 '17 at 12:31

3

Be it a static method or final variable or both, makes no difference. The scope of a local variable means that this assignment will happen every time (except for when it's optimised*).

However, when it comes to the strings in your example, the strings will come from the string pool. So the assignments happen each time, but they will all reference the same string instance.

*Optimisation - The JIT compiler may inline the values, so each solution may run exactly as fast as another. So you should not try to micro optimize yourself unless you are aware of an actual performance problem.

edited May 23 '17 at 12:31

Community

1
1

answered May 11 '16 at 08:56

weston

54,145
21
145
203

Thanks for mentioning the string pool, very valuable knowledge. Of course, premature optimization is the root of all evil. Just have a curious mind. – Filip Allberg May 11 '16 at 09:16

davmac · Answer 2 · 2016-05-11T09:13:45.500

In Java are unmodified method variables, that lack the final, qualifier re-initialized each time

(that the method is called) - of course they are, otherwise they would be uninitialized.

I think what you really wanted to ask was, can this initialisation be optimized out in some way? If the variable is assigned a constant value, then yes; the JIT compiler might remove the variable altogether, and replace references to it with its (known constant) value.

would the final qualifier allow Java to perform an optimization and store the method variable only once?

No. A final-qualified local variable can not have its value changed, but each invocation of a method has its own copy of the variable, and different instantiations might use different values for the same final variable. Consider:

void someMethod()
{
   final int number = new Random().nextInt();
}

The value cannot be assigned only once during program execution, because it is different each time the method is called.

The final modifier on a local variable has little or no direct effect on optimisation. It only places restrictions on what can be done with the variable - restrictions which might be followed for any variable, regardless of final qualification - and this in turn allows certain optimisations. If the optimizer is worth its salt, it won't care if the variable is declared final and will instead consider if it is effectively constant.

Of course! Now it clicked. I should have realized this solely from the fact that method variables are thread-safe. — Filip Allberg, May 11 '16 at 09:14
@FilipAllberg And for other variables, the JIT does not care. Unless you declare a variable `volatile` or perform something forcing them to be in sync, the compiler is free to assume that no other thread modifies any variable. It may avoid redundant loads and stores at will. This makes sense as without synchronization, volatile and friends, there's no visibility guarantee in the Java Memory Model (which corresponds with the behaviour of the hardware; think per core caches). — maaartinus, May 12 '16 at 00:15

Java Static/Instance method optimization

2 Answers2