WeakReference is cleared while other references are created

Question

Is it possible that while a weak reference is being cleared, another reference is created to the object, resulting the get() method of the reference to return null although the object still exist in memory? I have the following example code:
WeakReference ref = new WeakReference(new Object());
Object obj1 = ref.get();
Object obj2 = ref.get();
if(obj1 != null && obj2 == null)
System.out.println("obj1 is not null and obj2 is null!!!");
}Is it possible that the reference is cleared in parallel to this code, means that GC started cleanup and in the mean time the code calls the first get() and has a reference, while the second get() is after the cleanup and will return null? I'm seeing this in a more complex code that I have but didn't manage to reproduce it with a simple case. I'm using weak references for caching and at some point have a "miss" in the cache although the object is still in memory and has referneces.
Thank you!
Noam

Answer 1

I do like to have the behavior of WeakReference in my application since soft references cause the application to consume large amount of real memory and this is a problem (it'll prevent other applications from using this memory).
Here is more detailed code - below is the class which is used for caching. I might be able to replace it with WeakHashMap - I'll also try it. But basically, it gives the same functionality.
public class ReferenceCache implements IAlarmClockRegistration
     private static Logger log = Logger.getLogger(ReferenceCache.class);
     public static final long DEFAULT_CLEAN_INTERVAL_MILLI = 1 * 60 * 1000; // 1 minute
     public static final int REFERENCE_TYPE_STRONG = 1;
     public static final int REFERENCE_TYPE_SOFT = 2;
     public static final int REFERENCE_TYPE_WEAK = 3;
     private long m_lCleanIntervalMilli = DEFAULT_CLEAN_INTERVAL_MILLI;
     private Map m_mapReferences = new HashMap();
     private ReferenceQueue m_rqQueue = new ReferenceQueue();
     private int m_iReferenceType;
   public ReferenceCache()
        this(REFERENCE_TYPE_WEAK);
     public ReferenceCache(int iReferenceType)
         m_iReferenceType = iReferenceType;
         register();
     private Reference createReference(Object obj, String key)
          switch(m_iReferenceType)
               case REFERENCE_TYPE_STRONG : return new StrongReferenceWrapper(obj, key, m_rqQueue);
               case REFERENCE_TYPE_SOFT   : return new SoftReferenceWrapper(obj, key, m_rqQueue);
               case REFERENCE_TYPE_WEAK : return new WeakReferenceWrapper(obj, key, m_rqQueue);
               default: throw new RuntimeException("unknown reference  type");
     public synchronized void put(String id, Object obj)
          if (log.isDebugEnabled())
               log.debug("put() - id=" + id);
          Reference ref = (Reference)m_mapReferences.get(id);
          if(ref != null)
               ref.clear();
          m_mapReferences.put(id, createReference(obj, id));
     public boolean referenceExists(String id)
          if (log.isDebugEnabled())
               log.debug("referenceExists() - id=" + id);
          Reference ref = (Reference)m_mapReferences.get(id);
          return (ref != null);
     public synchronized Object get(String id)
          if (log.isDebugEnabled())
               log.debug("get() - id=" + id);
          Reference ref = (Reference)m_mapReferences.get(id);
          if(ref == null)
               log.debug("get() - ref is null");
               return null;
          return ref.get();
     public synchronized void clear(String id)
          if (log.isDebugEnabled())
               log.debug("clear() - id=" + id);
          Reference ref = (Reference)m_mapReferences.get(id);
          if(ref != null)
               ref.clear();
               m_mapReferences.remove(id);
               synchronized(ref)
                    ref.notify();
     private synchronized void clean()
          log.debug("clean() - [in]");
          Reference reference = null;
          while (null != (reference = (Reference) m_rqQueue.poll()))
               String key = ((IReferenceWrapper)reference).getKey();
               m_mapReferences.remove(key);
     private void register()
          AlarmClock.getInstance().register(m_lCleanIntervalMilli, this);
     public void wakeUp(long id)
          try
               clean();
          catch(Throwable t)
               log.error("wakeUp() - caught exception", t);
          finally
               register();
}This is how the cache is used:
     public boolean store(IDirectoryEntry entry) throws Exception
          synchronized(m_lckRefMap)
               // here there is some code to store object on disk
               m_cache.put(entry.getUniqueID(), obj);
               return true;
     public Object retreive(String strKey) throws SQLException
          synchronized(m_lckRefMap)
               // look in the cache first
               IDirectoryEntry entry = (IDirectoryEntry)m_cache.get(strKey);
               if(entry != null)
                    return entry;
                                                // here there is a code to read object from disk
              }