ADDITIONAL SYSTEM INFORMATION :
Windows 7 64-Bit, JRE 10.0.2 (10.0.1)

A DESCRIPTION OF THE PROBLEM :
A Java main program (running with JRE-A e.g. 10.0.1, located at a/java) is starting a new Java process with an alternate JRE-B (e.g. 10.0.2 located at b/java) and terminates itself. The new process has still a handle to the modules file from JRE-A. Strangely, it has handles to both modules file in a/java/lib and b/java/lib.

REGRESSION : Last worked in version 8u181

STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
(1) create dir c:\temp\test\    
(2) copy JRE 10.0.1  to  c:\temp\test\a\java\    
	directories in c:\temp\test\:
		c:\temp\test\a\java\release
		c:\temp\test\a\java\README.html
		c:\temp\test\a\java\bin\*
		...
(3) copy JRE 10.0.2  to  c:\temp\test\b\java\    
	additional directories in c:\temp\test\:
		c:\temp\test\b\java\release
		c:\temp\test\b\java\README.html
		c:\temp\test\b\java\bin\*
		...
(4) start cmd terminal window and cd to c:\temp\test
(5) set environment to JRE-A
	> set JAVA_HOME=c:\temp\test\a\java
	> set JRE_HOME=%JAVA_HOME%
	> set PATH=%JAVA_HOME%\bin\;%PATH%
(6) copy TestRestartWithNewJre.class to c:\temp\test
(7) run the test program    with parameter  -newjre C:\temp\test\b\java    
	> java -cp . TestRestartWithNewJre -newjre C:\temp\test\b\java
(8) check the result:
	(a) check p1.log: it shows the PID, the environment and properties of the starting process (JRE-A)
	(b) check the task-manager: the starting process (with JRE-A) does not exist anymore
	(c) check p2.log: it shows the PID, the environment and properties of the started process (JRE-B)
		There is also an AccessDeniedException. This is thrown, because the renaming of the JRE-A home dir (a\java -> a\java-<timestramp>) failed.
	(d) check the task-manager: the started process (with JRE-B) is still in process-list (sleeps for 1h)
	(e) The Process-Explorer (procexp.exe, from Windows SysInternals) shows, that the started Java process (JRE-B) has handles to both modules file (from JRE-A and JRE-B)


EXPECTED VERSUS ACTUAL BEHAVIOR :
EXPECTED -
The started process (using JRE-B) shouldn't have any reference to files in JRE-A
ACTUAL -
The Process-Explorer (procexp.exe, from Windows SysInternals) shows, that 
(a) the first process (using JRE-A) does not exist anymore
(b) the started Java process (JRE-B) has handles to both modules file (from JRE-A and JRE-B)

---------- BEGIN SOURCE ----------
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.nio.file.StandardOpenOption;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class TestRestartWithNewJre {

	private static String logFile = "p1.log";
	private static String oldJreHome = null;
	private static String newJreHome = null;
	
	public static void main(String[] args) {
		TestRestartWithNewJre t = new TestRestartWithNewJre();

		try {
			//get params
			setParams(args);
			
			//delete logfiles
			new File( logFile ).delete();
			
			//log params and all system properties
			log("args: " + Arrays.asList(args));
			dumpMap("properties: ", (Map) System.getProperties() );
			dumpMap("env: ", System.getenv() );
			
			// restart with alternate JRE or rename the old one 
			t.start();
		} catch (IOException e) {
			log("IOException found", e);
			log("plese check first which file is locked.....  (process sleep for 1h)");
			
			try {
				Thread.sleep(1000 * 60 * 60);
			} catch (InterruptedException e1) {
				log("sleep interrupted", e1);
			}
		} catch (Exception e) {
			log("error", e);
		}
	}

	
	private void start() throws IOException {
		
		// if new jre home is given, restart this job with the new JRE and put the reference to the old JRE as parameter "-oldjre" (for renaming later on)
		if( newJreHome != null ) {
			File newJreHomeDir = new File(newJreHome);
			if( newJreHomeDir.exists() && newJreHomeDir.isDirectory() ) {
				List<String> cmdItems = new ArrayList<String>();
				String javaExecutable = getJavaExe(newJreHomeDir);
				cmdItems.add(javaExecutable);
				cmdItems.add("-classpath");
				String jarName = getJarName();
				cmdItems.add(jarName);
				cmdItems.add(this.getClass().getName());
				cmdItems.add("-oldjre");
				String jreHome = System.getProperty("java.home");
				cmdItems.add(jreHome);
				cmdItems.add("-logfile");
				cmdItems.add("p2.log");
				
				invokeNewProcess(newJreHome, cmdItems);
				System.exit(1);
			} else {
				log("new JRE home '" + newJreHome + "' does not exist");
				System.exit(1);
			}
			
		} else if( oldJreHome != null ) {
			log("sleep for 2 seconds first, before trying to rename old/unused JRE-home");
			try {
				Thread.sleep(1000 * 2);
			} catch (InterruptedException e1) {
				log("sleep interrupted", e1);
			}
			
			// if old/unused jre home is given, try to rename it
			File oldJreHomeDir = new File(oldJreHome);
			if( oldJreHomeDir.exists() && oldJreHomeDir.isDirectory() ) {
				File targetPath = new File(oldJreHomeDir.getParentFile(), oldJreHomeDir.getName() + "-" + System.currentTimeMillis());
				
				log("try to move '" + oldJreHome + "' to '" + targetPath.getAbsolutePath() + "'");
				
				Path movedTargetPath = Files.move(oldJreHomeDir.toPath(), targetPath.toPath(), StandardCopyOption.ATOMIC_MOVE);
				if( movedTargetPath.toFile().exists() ) {
					log("rename '" + oldJreHome + "' to '" + movedTargetPath.toString() + "' done with success");
				} else {
					log("rename '" + oldJreHome + "' to '" + movedTargetPath.toString() + "' failed");
				}
			} else {
				log("wrong parameter -oldjre '" + oldJreHome + "', path does not exist");
				System.exit(1);
			}
		}
		
		
	}


	/*
	 * get params
	 */
	private static void setParams(String[] args) {
		for( int i=0; i<args.length; i++ ) {
			switch( args[i] ) {
			case "-oldjre":
				if( i+1 < args.length ) {
					oldJreHome = args[++i];
				}
				break;
			case "-newjre":
				if( i+1 < args.length ) {
					newJreHome = args[++i];
				}
				break;
			case "-logfile":
				if( i+1 < args.length ) {
					logFile = args[++i];
				}
				break;
			}
		}
	}
	
	
	/*
	 * get the name of this jar (for restart with alternate jre)
	 */
	private String getJarName() {
		return this.getClass().getProtectionDomain().getCodeSource().getLocation().getPath();
	}

	/*
	 * determine the path/name of the java executable for the given JRE home (the alternate jre for restart !)
	 */
	private String getJavaExe(final File javaHomeDir) throws IOException {
		final Path start = javaHomeDir.toPath();
		final int maxDepth = 5;
		final StringBuilder sb = new StringBuilder("");
		try (Stream<Path> stream = Files.find(start, maxDepth, (path, attr) -> ((String.valueOf(path).endsWith("java.exe")||String.valueOf(path).endsWith("java"))&&path.toFile().isFile()&&(path.toFile().canExecute())))) {
			sb.append( stream.sorted().map(String::valueOf).collect(Collectors.joining(";")) );
		}
		String javaExe[] = sb.toString().split(";");
		if( javaExe.length != 1 ) {
			throw new RuntimeException("java executable not found: " + Arrays.asList(javaExe));
		}
		File javaExeFile = new File(javaExe[0]);
		boolean javaExecutableFound = javaExeFile != null && javaExeFile.exists() && javaExeFile.isFile() && javaExeFile.canRead() && javaExeFile.canExecute();
		if( !javaExecutableFound ) {
			throw new RuntimeException("java file not executable: " + javaExeFile.getAbsolutePath());
		}
		log("getJavaExe: " + javaExeFile.getCanonicalPath() );
		return javaExeFile.getCanonicalPath();
	}

	/*
	 * invoke the new process (with alternate JRE)
	 */
	private void invokeNewProcess(String newJavaHome, List<String> cmdItems) throws IOException {
		log("try to start process: " + cmdItems);
		final ProcessBuilder pb = new ProcessBuilder(cmdItems);
		Map<String,String> pbEnv = pb.environment();
		if( newJavaHome != null ) {
			pbEnv.clear();
			pbEnv.put("JRE_HOME", newJavaHome);
			pbEnv.put("JAVA_HOME", newJavaHome);
		}
		dumpMap("env for new process: ", pbEnv);
		
		pb.redirectErrorStream(true);
		pb.redirectInput();
	    final Process process = pb.start();			
		log("process is started: " + process.isAlive());
	}
	
	/*
	 * log the current map  (env or system properties)
	 */
	private static void dumpMap(final String label, final Map<String,String> map) {
		Set<String> keys = map.keySet();
		java.util.List<String> sortedKeys = new ArrayList<String>(keys);
		Collections.sort(sortedKeys);
		StringBuilder buf = new StringBuilder(label).append(System.lineSeparator());
		for (Iterator<String> iter = sortedKeys.iterator(); iter.hasNext();) {
			String key = iter.next();
			String value = map.get(key);
			buf.append("\t" + key + "=" + value).append(System.lineSeparator());
		}
		log(buf.toString());
	}
	
	/*
	 * log msg
	 */
	private static void log(String msg) {
		log(msg, null);
	}
	
	/*
	 * log msg and exception (if not null)
	 */
	private static void log(String msg, Exception ex ) {
		final DateFormat df = new SimpleDateFormat("yyyyMMdd HH:mm:ss SSS ");
		String pid = " PID: " + getPID() + ", ";
		try {
			
			Files.write(Paths.get(logFile), (df.format(new Date()) + pid + msg + System.lineSeparator()).getBytes("UTF-8"),StandardOpenOption.CREATE,StandardOpenOption.APPEND);
			if( ex != null ) {
				ByteArrayOutputStream bo = new ByteArrayOutputStream();
				PrintStream ps = new PrintStream(bo);
				ex.printStackTrace(ps);
				Files.write(Paths.get(logFile), (df.format(new Date()) + pid + bo.toString() + System.lineSeparator()).getBytes("UTF-8"),StandardOpenOption.CREATE,StandardOpenOption.APPEND);
			}			
		} catch (Exception e) {
			//ignore
		}
	}
	
	/*
	 * determin the current PID
	 */
	private static long getPID() {
		try {
		    String processName = java.lang.management.ManagementFactory.getRuntimeMXBean().getName();
		    return Long.parseLong(processName.split("@")[0]);
		} catch( Exception ex ) {
			return -999;
		}
	  }	
}

---------- END SOURCE ----------

FREQUENCY : always