Re: Data structure to keep things in memory

On 28/11/10 18:18, Mike Schilling wrote:


Hmm, I was under the impression that the ReferenceQueue kept track of
References, but I see it's the other way around (looking at the source).

So you need a container of RTSUsers. That was served by the
Map<Reference<RTSHandle>, RTSImpl> in ClassCastException's original
suggestion, and a Collection<RTSUser> will suffice here.

If you have to keep all your RTSImpls anyway, you could make each one
point to its RTSUser, so the container of RTSImpls indirectly hangs on
to the RTSUsers. I was originally thinking of a case where getRTS()
took some sort of key, and mapped it to an RTSImpl, which referenced its
(multiple) RTSUsers, so that map did the job implicitly.

Maybe you can get away with a ConcurrentMap<Key, RTSUser>, if you want
to avoid synchronization:

ConcurrentMap<Key, RTSUser> map;

RTS getRTS(Key key) {
    // Create an implementation for 'key', even if we don't
    // ultimately use it.
    RTSImpl impl = createFor(key);

    // Create a proxy for it.
    RTSHandle proxy = proxify(impl);

    // Create a weak reference to the proxy, so we can monitor its
    // discard.
    RTSUser user = new RTSUser(proxy, queue, impl, key);

    for ( ; ; ) {
        // Stick it in the map if there isn't one there already.
        RTSUser oldUser = map.putIfAbsent(key, user);

        // See if we can still get a strong reference to the proxy
        // that the map does hold.
        RTSHandle oldProxy = oldUser.get();

        if (oldProxy == null) {
            // No, we'll have to put ours in anyway, if the old
            // one is still in there.
            if (map.replace(key, oldUser, user))
                // It was still there.
                return proxy;
            // It had gone (perhaps replaced, perhaps removed), so
            // try again.
            continue;
        } else {
            // Yes, we'll just use what's in the map, and discard
            // our impl.
            return oldProxy;
        }
    }
}

The RTSUser additionally should take the Key as well, and use
map.remove(key, this) to remove itself.