diff --git a/runtime/src/com/sun/xml/bind/v2/runtime/reflect/opt/Injector.java b/jaxb-ri/runtime/src/com/sun/xml/bind/v2/runtime/reflect/opt/Injector.java
index 33cc124..f41944f 100644
--- a/runtime/src/com/sun/xml/bind/v2/runtime/reflect/opt/Injector.java
+++ b/runtime/src/com/sun/xml/bind/v2/runtime/reflect/opt/Injector.java
@@ -41,6 +41,7 @@ import java.lang.reflect.Method;
 import java.lang.ref.WeakReference;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.WeakHashMap;
@@ -67,10 +68,8 @@ final class Injector {
      *
      * We only need one injector per one user class loader.
      */
-    private static final Map<ClassLoader,WeakReference<Injector>> injectors =
-//        Collections.synchronizedMap(new WeakHashMap<ClassLoader,WeakReference<Injector>>());
-        new WeakHashMap<ClassLoader,WeakReference<Injector>>();
-
+    private static final Map<ClassLoader,Injector> injectors =
+        Collections.synchronizedMap(new WeakHashMap<ClassLoader,Injector>());
     private static final Logger logger = Util.getClassLogger();
 
     /**
@@ -82,7 +81,7 @@ final class Injector {
     static Class inject( ClassLoader cl, String className, byte[] image ) {
         Injector injector = get(cl);
         if(injector!=null)
-            return injector.inject(className,image);
+            return injector.internalInject(cl,className,image);
         else
             return null;
     }
@@ -93,7 +92,7 @@ final class Injector {
     static Class find( ClassLoader cl, String className ) {
         Injector injector = get(cl);
         if(injector!=null)
-            return injector.find(className);
+            return injector.internalFind(cl,className);
         else
             return null;
     }
@@ -105,14 +104,11 @@ final class Injector {
      *      if it fails.
      */
     private static Injector get(ClassLoader cl) {
-        Injector injector = null;
         synchronized(injectors){
-            WeakReference<Injector> wr = injectors.get(cl);
-            if(wr!=null)
-                injector = wr.get();
+            Injector injector = injectors.get(cl);
             if(injector==null)
                 try {
-                    injectors.put(cl,new WeakReference<Injector>(injector = new Injector(cl)));
+                    injectors.put(cl,injector = new Injector(cl));
                 } catch (SecurityException e) {
                     logger.log(Level.FINE,"Unable to set up a back-door for the injector",e);
                     return null;
@@ -124,9 +120,7 @@ final class Injector {
     /**
      * Injected classes keyed by their names.
      */
-    private final Map<String,Class> classes = new HashMap<String,Class>();
-
-    private final ClassLoader parent;
+    private final Map<String,WeakReference<Class>> classes = new HashMap<String,WeakReference<Class>>();
 
     /**
      * True if this injector is capable of injecting accessors.
@@ -160,7 +154,6 @@ final class Injector {
     }
 
     private Injector(ClassLoader parent) {
-        this.parent = parent;
         assert parent!=null;
 
         boolean loadable = false;
@@ -175,11 +168,14 @@ final class Injector {
     }
 
 
-    private synchronized Class inject(String className, byte[] image) {
+    private synchronized Class internalInject(ClassLoader parent, String className, byte[] image) {
         if(!loadable)   // this injector cannot inject anything
             return null;
 
-        Class c = classes.get(className);
+        Class c = null;
+        WeakReference<Class> ref = classes.get(className); 
+        if (ref != null)
+            c = ref.get(); 
         //find loaded class from classloader
         if(c==null) {
                 try {
@@ -194,7 +190,7 @@ final class Injector {
                 }
 
                 if(c!=null) {
-                    classes.put(className,c);
+                    classes.put(className,new WeakReference<Class>(c));
                     return c;
                 }
         }
@@ -222,12 +218,32 @@ final class Injector {
                 logger.log(Level.FINE,"Unable to inject "+className,e);
                 return null;
             }
-            classes.put(className,c);
+            classes.put(className,new WeakReference<Class>(c));
         }
         return c;
     }
 
-    private synchronized Class find(String className) {
-        return classes.get(className);
+    private synchronized Class internalFind(ClassLoader parent, String className) {
+        Class clazz = null;
+         WeakReference<Class> ref = classes.get(className);
+         if (ref != null)
+         {
+            clazz = ref.get();
+            if (clazz==null)
+            {
+               // If we have a reference but no class the class must have been
+               // loaded at some point.
+               try {
+                  clazz = parent.loadClass(className);
+               } catch (ClassNotFoundException e) {
+                  // If this fails then null can be returned so the class can 
+                  // be redefined.
+                  logger.log(Level.FINE,"Unable to load "+className,e);
+               }
+             } 
+         }
+         
+         return clazz; 
+
     }
 }