diff --git a/class-model/src/main/java/org/glassfish/hk2/classmodel/reflect/impl/TypeImpl.java b/class-model/src/main/java/org/glassfish/hk2/classmodel/reflect/impl/TypeImpl.java
index 307e400..4ff1eb0 100755
--- a/class-model/src/main/java/org/glassfish/hk2/classmodel/reflect/impl/TypeImpl.java
+++ b/class-model/src/main/java/org/glassfish/hk2/classmodel/reflect/impl/TypeImpl.java
@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2023 Payara Foundation and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -48,6 +47,14 @@
 
     synchronized void addDefiningURI(URI uri) {
         definingURIs.add(uri);
+        try {
+            File file = new File(uri);
+//            assert(file.exists()) : file + " does not exist";
+            definingURIs.add(file.getCanonicalFile().toURI());
+        } catch (IOException e) {
+            // ignore, this is a safeguard for confused user's code that do not
+            // deal well with file path.
+        }
     }
 
     @Override
diff --git a/hk2-api/src/main/java/org/glassfish/hk2/internal/InheritableThreadContext.java b/hk2-api/src/main/java/org/glassfish/hk2/internal/InheritableThreadContext.java
index 1d35d7d..ea4c47c 100755
--- a/hk2-api/src/main/java/org/glassfish/hk2/internal/InheritableThreadContext.java
+++ b/hk2-api/src/main/java/org/glassfish/hk2/internal/InheritableThreadContext.java
@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2014, 2018 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2023 Payara Foundation and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +17,6 @@
 package org.glassfish.hk2.internal;
 
 import java.lang.annotation.Annotation;
-import org.glassfish.hk2.utilities.CleanerFactory;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.HashMap;
@@ -116,14 +114,10 @@
     }
 
     private static class InheritableContextThreadWrapper {
-        
-        private final HashMap<ActiveDescriptor<?>, Object> instances = new HashMap<>();
+        private final HashMap<ActiveDescriptor<?>, Object> instances =
+                new HashMap<ActiveDescriptor<?>, Object>();
         private final long id = Thread.currentThread().getId();
 
-        public InheritableContextThreadWrapper() {
-            registerStopEvent();
-        }
-
         public boolean has(ActiveDescriptor<?> d) {
             return instances.containsKey(d);
         }
@@ -136,14 +130,13 @@
             instances.put(d, v);
         }
 
-        public final void registerStopEvent() {
-            CleanerFactory.create().register(this, () -> {
-                instances.clear();
+        @Override
+        public void finalize() throws Throwable {
+            instances.clear();
 
-                if (LOG_THREAD_DESTRUCTION) {
-                    Logger.getLogger().debug("Removing PerThreadContext data for thread " + id);
-                }
-            });
+            if (LOG_THREAD_DESTRUCTION) {
+                Logger.getLogger().debug("Removing PerThreadContext data for thread " + id);
+            }
         }
 
     }
diff --git a/hk2-api/src/main/java/org/glassfish/hk2/internal/PerThreadContext.java b/hk2-api/src/main/java/org/glassfish/hk2/internal/PerThreadContext.java
index 0ae3a88..c04147c 100755
--- a/hk2-api/src/main/java/org/glassfish/hk2/internal/PerThreadContext.java
+++ b/hk2-api/src/main/java/org/glassfish/hk2/internal/PerThreadContext.java
@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2012, 2018 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2023 Payara Foundation and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -18,7 +17,6 @@
 package org.glassfish.hk2.internal;
 
 import java.lang.annotation.Annotation;
-import org.glassfish.hk2.utilities.CleanerFactory;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.HashMap;
@@ -119,14 +117,10 @@
     }
     
     private static class PerContextThreadWrapper {
-
-        private final HashMap<ActiveDescriptor<?>, Object> instances = new HashMap<>();
+        private final HashMap<ActiveDescriptor<?>, Object> instances =
+                new HashMap<ActiveDescriptor<?>, Object>();
         private final long id = Thread.currentThread().getId();
-
-        public PerContextThreadWrapper() {
-            registerStopEvent();
-        }
-                
+        
         public boolean has(ActiveDescriptor<?> d) {
             return instances.containsKey(d);
         }
@@ -139,14 +133,13 @@
             instances.put(d, v);
         }
         
-        public final void registerStopEvent() {
-            CleanerFactory.create().register(this, () -> {
-                instances.clear();
-
-                if (LOG_THREAD_DESTRUCTION) {
-                    Logger.getLogger().debug("Removing PerThreadContext data for thread " + id);
-                }
-            });
+        @Override
+        public void finalize() throws Throwable {
+            instances.clear();
+            
+            if (LOG_THREAD_DESTRUCTION) {
+                Logger.getLogger().debug("Removing PerThreadContext data for thread " + id);
+            }
         }
         
     }
diff --git a/hk2-api/src/main/java/org/glassfish/hk2/utilities/CleanerFactory.java b/hk2-api/src/main/java/org/glassfish/hk2/utilities/CleanerFactory.java
deleted file mode 100644
index a53a18d..0000000
--- a/hk2-api/src/main/java/org/glassfish/hk2/utilities/CleanerFactory.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (c) 2023 Payara Foundation and/or its affiliates. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v. 2.0, which is available at
- * http://www.eclipse.org/legal/epl-2.0.
- *
- * This Source Code may also be made available under the following Secondary
- * Licenses when the conditions for such availability set forth in the
- * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
- * version 2 with the GNU Classpath Exception, which is available at
- * https://www.gnu.org/software/classpath/license.html.
- *
- * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
- */
-package org.glassfish.hk2.utilities;
-
-import java.lang.ref.Cleaner;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
-import java.util.concurrent.ThreadFactory;
-
-/**
- * CleanerFactory provides a Cleaner reference which is created on the first
- * reference to the CleanerFactory.
- */
-public final class CleanerFactory {
-
-    /* The common Cleaner. */
-    private final static Cleaner commonCleaner = Cleaner.create(new ThreadFactory() {
-        @Override
-        public Thread newThread(final Runnable r) {
-            return AccessController.doPrivileged(new PrivilegedAction<>() {
-                @Override
-                public Thread run() {
-                    Thread t = new Thread(null, r, "Common-Cleaner");
-                    t.setPriority(Thread.MAX_PRIORITY - 2);
-                    return t;
-                }
-            });
-        }
-    });
-
-
-    /**
-     * This Cleaner will run on a thread whose context class loader
-     * is {@code null}. The system cleaning action to perform in
-     * this Cleaner should handle a {@code null} context class loader.
-     *
-     * @return a common cleaner reference
-     */
-    public static Cleaner create() {
-        return commonCleaner;
-    }
-}
diff --git a/hk2-core/src/main/java/com/sun/enterprise/module/impl/ClassLoaderFacade.java b/hk2-core/src/main/java/com/sun/enterprise/module/impl/ClassLoaderFacade.java
index 4dcb573..50f0a25 100755
--- a/hk2-core/src/main/java/com/sun/enterprise/module/impl/ClassLoaderFacade.java
+++ b/hk2-core/src/main/java/com/sun/enterprise/module/impl/ClassLoaderFacade.java
@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2023 Payara Foundation and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -21,13 +20,11 @@
 
 import java.io.IOException;
 import java.io.PrintStream;
-import org.glassfish.hk2.utilities.CleanerFactory;
 import java.net.URL;
 import java.net.URLClassLoader;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.ArrayList;
-import java.util.logging.Level;
 
 /**
  * Facade for {@link ModuleClassLoader} to only expose public classes.
@@ -46,14 +43,12 @@
     public ClassLoaderFacade(ModuleClassLoader privateLoader) {
         super(EMPTY_URLS, privateLoader.getParent());
         this.privateLoader = privateLoader;
-        registerStopEvent();
     }
 
-    public final void registerStopEvent() {
-        CleanerFactory.create().register(this, () -> {
-            LogHelper.getDefaultLogger().log(Level.FINE, "Facade ClassLoader killed {0}", privateLoader.getOwner().getModuleDefinition().getName());
-            privateLoader.stop();
-        });
+    protected void finalize() throws Throwable {
+        super.finalize();
+        LogHelper.getDefaultLogger().fine("Facade ClassLoader killed " + privateLoader.getOwner().getModuleDefinition().getName());
+        privateLoader.stop();
     }
 
     public void setPublicPkgs(String[] publicPkgs) {
diff --git a/hk2-core/src/main/java/com/sun/enterprise/module/impl/ClassLoaderProxy.java b/hk2-core/src/main/java/com/sun/enterprise/module/impl/ClassLoaderProxy.java
index 2b6de0a..e9f8c62 100755
--- a/hk2-core/src/main/java/com/sun/enterprise/module/impl/ClassLoaderProxy.java
+++ b/hk2-core/src/main/java/com/sun/enterprise/module/impl/ClassLoaderProxy.java
@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2023 Payara Foundation and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -24,7 +23,6 @@
 import java.util.*;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.io.IOException;
-import org.glassfish.hk2.utilities.CleanerFactory;
 
 /**
  * ClassLoaderProxy capable of loading classes from itself but also from other class loaders
@@ -39,7 +37,11 @@
     /** Creates a new instance of ClassLoader */
     public ClassLoaderProxy(URL[] shared, ClassLoader parent) {
         super(shared, parent);
-        registerStopEvent();
+    }
+
+    protected void finalize() throws Throwable {
+        super.finalize();
+        stop();
     }
 
     protected Class<?> loadClass(String name, boolean resolve, boolean followImports)
@@ -191,7 +193,7 @@
     }
 
     public Collection<ClassLoader> getDelegates() {
-        return new ArrayList<>(surrogates);
+        return new ArrayList<ClassLoader>(surrogates);
     }
 
 
@@ -199,18 +201,11 @@
      * called by the facade class loader when it is garbage collected.
      * this is a good time to see if this module should be unloaded.
      */
-    public final void registerStopEvent() {
-        CleanerFactory.create().register(this, () -> {
-            stop();
-        });
-    }
-
     public void stop() {
-        surrogates.clear();
-        facadeSurrogates.clear();
+       surrogates.clear();
+       facadeSurrogates.clear();
     }
 
-    @Override
     public String toString() {
         StringBuffer s= new StringBuffer();
         s.append(",URls[]=");
diff --git a/hk2-core/src/main/java/com/sun/enterprise/module/impl/ModuleClassLoader.java b/hk2-core/src/main/java/com/sun/enterprise/module/impl/ModuleClassLoader.java
index 94de6f5..3b3d626 100755
--- a/hk2-core/src/main/java/com/sun/enterprise/module/impl/ModuleClassLoader.java
+++ b/hk2-core/src/main/java/com/sun/enterprise/module/impl/ModuleClassLoader.java
@@ -1,6 +1,5 @@
 /*
  * Copyright (c) 2007, 2018 Oracle and/or its affiliates. All rights reserved.
- * Copyright (c) 2023 Payara Foundation and/or its affiliates. All rights reserved.
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
@@ -50,6 +49,12 @@
         super(shared, parent);
         this.module = owner;
     }
+    
+    protected void finalize() throws Throwable {
+        super.finalize();
+        LogHelper.getDefaultLogger().info("ModuleClassLoader gc'ed " + module.getModuleDefinition().getName());
+    }
+
 
     protected synchronized Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {
         initialize(name);
