Unexpected partial hot code replacement in nondebug mode

[xerces8]

Hi!

This may be a misunderstanding on my side, but here it is.

When running a Java program from Eclipse (I originally encountered this while running JUnit test cases in an older version of Eclipse, but plain Java programs in latest Eclipse behave the same) and the editing and saving the source code, the new version of the code will be used in some parts of the running app.

Steps:

• version used: eclipse-jee-2025-09-R-win32-x86_64.zip
  About menu shows:

Eclipse IDE for Enterprise Java and Web Developers (includes Incubating components)

Version: 2025-09 (4.37.0)
Build id: 20250905-1456

• open new workspace
• create a new "Java Project"
• create a new class, enter code source below
• run it with "Run As / Java Application" (Alt+Shift+X,J)
• while running change the value of the theValue variable to 999 and save (Ctrl+S)

Expected output:

first: 340
THREAD theValue = 340
second: 340

Actual output:

first: 340
THREAD theValue = 999
second: 340

package dummy;

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class Dummy {
	final static int theValue = 340;
	private final ExecutorService pool = Executors.newFixedThreadPool(2);

	void doIt() throws InterruptedException, ExecutionException {
		int first = theValue;
		System.out.println("first: " + first);

		try {
			Thread.sleep(5000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		Future<Object> task = pool.submit(new Callable<Object>() {
			public Object call() {
				System.out.println(" THREAD  theValue = " + theValue);
				return null;
			}
		});

		task.get();

		int second = theValue;
		System.out.println("second: " + second);

	}

	public static void main(String[] args) throws InterruptedException, ExecutionException {
		new Dummy().doIt();
	}
}

Changing the preference Java / Debug "Enable hot code replace" to disabled makes no change to the above behavior.

[iloveeclipse]

There are two classes in this class. Looks like anonymous class that prints THREAD theValue = 999 is loaded & executed before it is recompiled. Extract the code to a method in the "Dummy" class and most likely the printed values would be identical.

[xerces8]

Did you make a typo? 999 is the new value, after recompilation.

[iloveeclipse]

Just swap classes. One is recompiled, another isn't.

[xerces8]

The value that changes is in the "outer" class (class Dummy), which is loaded at program start. How does the anonymous class (even if itself loaded later), access a different copy of the class (which has the new variable value)?

Also: removing the "final" qualifier from the theValue variable definition changes the behavior, all three outputs write the original value (340). Maybe the compiler hardcodes the value in the inner class...

[iloveeclipse]

Maybe the compiler hardcodes the value in the inner class...

It is not "maybe" :)
You can see what is produced by compiler in the Bytecode Outline view.