Reference Objects and Pooling

Question

I am trying to create a Pool class that does not require the caller to explictly return the objects. I thought I might be able to use Phantomreference or WeakReference to detect when the user no longer had reference to the object and thus reclaim it and put it back in the pool. The issues with these are this:
1) WeakReference is cleared (clear()) before it is added to the ReferenceQueue not to mention the object is finalised before as well.
2) PhantomReference is not cleared but it is finalized. Not that it matters because you can never access the referant.
So what I did is subclass PhantomReference and created an Interface called Proxy. The subclass would take a proxy referant containing the actual reclaimable object and it would store the relaimable object as a hard referant and the proxy to that as the Phantom referant. Thus when the client was no longer using the proxy the erference would be added to the reference queue and I could get the actual reclaimable object as opposed to the proxy via a call to get().
The problem with this approach has been that not all classes lend well to being proxied. The idea situation would be that the Proxy would extend the actual class thus CASTING would work as normal.
public StringBufferProxy extends StringBuffer implements Proxy {
private StringBuffer proxy;
public StringBufferProxy(StringBuffer proxy)
this.proxy = proxy;
public Object getProxied()
return proxy;
public void anyMethod()
proxy.anyMethod();
The obvious problem with the above is that StringBuffer is final and thus can't be extended. Similar problems with Thread as it relates to its final methods. So in the end after going around in circles for awhile I realized this concept would only really be practicle for Interface based classes.
Has anyone else worked this problem and solved it?
}

Answer 1

all cases the referant has allready been finalized. In...
So what I tried to do was create a proxy class that
wraps the actual pooled item....
This has numerous problems.You may like my method. Someone needs to tell me if this is a ``bad thing'' but I've used it quite successfully. I wrote a cache class a little while ago (very similar to your Pool needs). It's a cloning cache. Let me simplify a VERY complex cache:
class Clone implements Cloneable {
    private Object o;
    Clone(Object o) {
        super();
        this.o = o;
    public Object getObject() { return o; }
    public Clone getClone() throws ... {
        return (Clone)super.clone();
} // CloneThis sets up the clone, now:
class CloneReference extends WeakReference implements Comparable { // or extend any Reference that makes sense to you
    private Clone clone = null;
    CloneReference(Clone referent, ReferenceQueue q) throws ... {
        super(referent,q);
        try {  // don't really have to try, but...
            clone = (Clone)referent.getClone();
        } catch(Exception dowhatever) { ... }
    public Object getObject() {
        Object ret = null;
        if(clone!=null) ret = clone.getObject();
        return ret;
    // now implement Comparable
} // CloneReferenceNow in your Pool maintain your ReferenceQueue, when you add a new Object into it, purgue this queue. In my cache I have a CacheEvent/CacheListener that is event fired during the purging of this queue. More later. When adding a new object into your Pool, add a reference to a new CloneReference object:
private ReferenceQueue q;  // init elsewhere
public void add(Object o) throws ... {
    CloneReference cr = new CloneReference(
          new Clone(obj)
        , q
    // now add this cr, not the o
}When purging the queue, poll() your ReferenceQueue and then obtain the CloneReference. Get your object back out (this will not be null or yet finalized) using CloneReference.getObject(), then fire off your interpretation of my CacheEvent to your version of my CacheListener.
Note that the ReferenceQueue maintains a reference to the original Clone, but the Reference itself has a clone of that Clone which we will NOT be GCd or nullified still maintaining a reference to the original object.
If you need further help I can probably provide a truncated source of a simple Cache.