Unused referenced variables always captured in Java

Question

I wanted to know if this is an implementation detail...

In Java, used local variables are captured for anonymous classes, and lambdas. For anonymous classes, the this is also captured in a non static context whether needed or not.

It appears, however, any local variable referenced is captured even if not used for Oracle JDK 8 update 181.

public static void main(String[] args) {
    Thread t = Thread.currentThread();
    Runnable run = new Runnable() {
        @Override
        public void run() {
            t.yield();
        }
    };
    Runnable run2 = () -> t.yield();
    run.run();
    run2.run();
}

the byte code for the anonymous Runnable is

  // access flags 0x1
  public run()V
   L0
    LINENUMBER 8 L0
    ALOAD 0
    GETFIELD UnusedLocalVariable$1.val$t : Ljava/lang/Thread;
    POP
    INVOKESTATIC java/lang/Thread.yield ()V
   L1
    LINENUMBER 9 L1
    RETURN
   L2
    LOCALVARIABLE this LUnusedLocalVariable$1; L0 L2 0
    MAXSTACK = 1
    MAXLOCALS = 1

As you can see, it captures the local variable which it loads, but always discards at runtime.

The lambda does much the same, also capturing the variable.

Is this always the case, or an implementation detail?

This is tagged as Java 8, but is it specific to Java 8? As in, have you tested on anything more recent, or do you have any reason to believe that the behaviour is now different? — Michael, Nov 08 '18 at 10:19
`t` is only unused by accident - because `Thread.yield()` is a static method. If you would call `t.setName("someName")` it would require the capturing of `t`. Maybe the java compiler is just not smart enough to avoid the capturing of "seemingly used, but effectively unused" local variables. — Thomas Kläger, Nov 08 '18 at 10:53
@ThomasKläger I can understand this is an optimisation which the Oracle javac just doesn't do, but is this because it is not allowed e.g. like `this` or because it's non trivial. — Peter Lawrey, Nov 08 '18 at 10:59
I think this optimization is not trivial - it would require a data flow analysis on a more involved level than `boolean x = true; if (x) System.out.println("Hello World!");` - the java compiler does not even optimize away this simple if statement. — Thomas Kläger, Nov 08 '18 at 18:25
@ThomasKläger it could, but `x` is not `final`, so it doesn’t. When you declare `x` as `final boolean x = false;` and have an inner class/lambda expression doing `if(x) System.out.println(y);`, the compiler will optimize away the code, resulting in a sole `RETURN` instruction, but still capture `y`. — Holger, Nov 08 '18 at 18:46
Different question, but related: https://stackoverflow.com/questions/53203529/are-all-final-variables-captured-by-anonymous-classes/53203930#53203930 — Hulk, Nov 09 '18 at 13:34

score 7 · Accepted Answer · edited Jun 20 '20 at 09:12

The specification makes no difference between “referencing” and “using” a variable. In that regard, you are using the variable by invoking t.yield(), despite you’re invoking a static method. For this scenario, the specification says

JLS §15.12.4.1, 15.12.4.1. Compute Target Reference (If Necessary):

If form is ExpressionName . [TypeArguments] Identifier, then:

If the invocation mode is static, then there is no target reference. The ExpressionName is evaluated, but the result is then discarded.

Otherwise, the target reference is the value denoted by ExpressionName.

so the behavior is in line with the specification.

While it’s clear that the evaluation must happen, when it has side effects, I would not go so far to conclude that the bytecode sequence ALOAD 0, GETFIELD, POP is strictly required to fulfill the formal rule that the variable is evaluated and the result is discarded, as that code has no effect at all.

But regardless of whether these instruction are present, the variable t is used and hence subject to the formal requirements, i.e. it must be effective final.

Whether this mandated behavior has to result in capturing the value within the instance of the inner class resp. the class generated for the lambda expression, is, perhaps surprisingly, entirely unspecified. The Java Language Specification does not say anything about it.

In other words, while you are asking about a corner case of the value capturing, i.e. the value of a variable which is referenced but not needed, even the general case, i.e. the well-known rule that inner classes always keep a reference to the enclosing this, even if unneeded, while lambda expression do not, does not appear anywhere in the official specification.

who else would bring clarity into this unless you? – Eugene Nov 09 '18 at 03:14 — Eugene, Nov 09 '18 at 03:14

Unused referenced variables always captured in Java

1 Answers1