Re: Data structure to keep things in memory

I've done something similar, except that I extended WeakReference so
that it contained a strong reference to the base object (RTS in this
case), rather than having the Map<Ref,RTS>. The WeakReference class
also implemented Runnable, so all the polling thread has to do is cast
the returned reference to Runnable and invoke it. In the OP's case, it
would look something like this:

// I'd make RTS an interface...
public interface RTS { ... }

// ...then make a (private) class implement it.
class RTSImpl implements RTS { ... }

// RTSHandle is just a proxy onto another RTS.
class RTSHandle implements RTS {
 final RTS base;
 RTSHandle(RTS base) { this.base = base; }
 // all methods just call onto base
}

class RTSUser extends WeakReference<RTSHandle> implements Runnable {
 final RTSImpl impl;

 RTSUser(RTSHandle handle,
         ReferenceQueue<? super RTSHandle> queue,
         RTSImpl impl) {
   super(handle, queue);
   this.impl = impl;
 }

 void run() {
   finishWith(impl);
 }
}

ReferenceQueue<Object> queue = new ReferenceQueue<Object>();

// The factory method
public RTS getRTS() {
 RTSImpl impl = new RTSImpl();
 RTSHandle handle = new RTSHandle(impl);
 RTSUser user = new RTSUser(handle, queue, impl);
 return handle;
}

void finishWith(RTSImpl impl) {
 ...
}

// Call this in a loop.
void expireOneRef() throws InterruptedException {
 Runnable action = (Runnable) queue.remove();
 action.run(); // Calls finishWith, if (action instanceof RTSUser).
}