public ReferenceQueue() 
{

}

Constructs a new reference-object queue.

 boolean enqueue(Reference<? extends T> r) 
{
 /* Called only by Reference class */
        synchronized (r) {
            if (r.queue == ENQUEUED) return false;
            synchronized (lock) {
                r.queue = ENQUEUED;
                r.next = (head == null) ? r : head;
                head = r;
                queueLength++;
                if (r instanceof FinalReference) {
                    sun.misc.VM.addFinalRefCount(1);
                }
                lock.notifyAll();
                return true;
            }
        }
}

 public Reference<? extends T> poll() 
{
        if (head == null)
            return null;
        synchronized (lock) {
            return reallyPoll();
        }
}

Polls this queue to see if a reference object is available. If one is available without further delay then it is removed from the queue and returned. Otherwise this method immediately returns null.

 public Reference<? extends T> remove() throws InterruptedException 
{
        return remove(0);
}

Removes the next reference object in this queue, blocking until one becomes available.

 public Reference<? extends T> remove(long timeout) throws IllegalArgumentException, InterruptedException 
{
        if (timeout <  0) {
            throw new IllegalArgumentException("Negative timeout value");
        }
        synchronized (lock) {
            Reference< ? extends T > r = reallyPoll();
            if (r != null) return r;
            for (;;) {
                lock.wait(timeout);
                r = reallyPoll();
                if (r != null) return r;
                if (timeout != 0) return null;
            }
        }
}

Removes the next reference object in this queue, blocking until either one becomes available or the given timeout period expires.

This method does not offer real-time guarantees: It schedules the timeout as if by invoking the Object#wait(long) method.