Alternative code

[Andrew Cottrell]

<p>The following code implements the same sort of idea, but doesn't impose on the Pool Manager</p>
<p>The idea is you'd create a Pool Manager (no interface to implement) to do the following
<ul>
<li>create a Pool object</li>
<li>add resources to the pool</li>
<li>remove resources from the pool</li>
</ul>
I guess the Pool Manager would often be a singlton. The obvious example would be a DatabaseConnectionManager for a JSP/Servlet website.</p>
<code>

package com.iname.andrewcottrell.util;

import java.util.LinkedList;

public class Pool {

    private static class Proxy {
        public Object resource;
        public void sleep(long timeout) {
               synchronized(this){
                   try {wait(timeout);}
                   catch (InterruptedException e) {}
               }
        }
        public void wake() {
               synchronized(this){
                   notifyAll();
               }
        }
        public String toString() {
            return "p";
        }
    }

    private LinkedList queue;
    private LinkedList available;
    private LinkedList unavailable;

    /** size of queue */
    public synchronized int queue() {
        return queue.size();
    }

    /** size of available */
    public synchronized int available() {
        return available.size();
    }

    /** size of unavailable */
    public synchronized int unavailable() {
        return unavailable.size();
    }

    /** size of total */
    public synchronized int total() {
        return available() + unavailable();
    }

    /**
     * Consutructs new Pool object
     */
    public Pool() {
        queue       = new LinkedList();
        available   = new LinkedList();
        unavailable = new LinkedList();
    }

    /**
     * adds new resource to the pool
     * returns true if the specified resource was added
     */
    public synchronized boolean add(Object resource) {
        if (
            resource == null ||
            available.contains(resource) ||
            unavailable.contains(resource)
        ) return false;
        return available.add(resource);
    }

    /**
     * removes a resource from the pool
     * the resource must have been checked
     * out of the pool
     * returns true if the specified resource was removed
     */
    public synchronized boolean remove(Object resource) {
        if (!unavailable.remove(resource)) return false;
        return true;
    }

    /**
     * gets a resource from the pool
     * waits until a free resource is
     * available
     */
    public Object get() {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(0);
        return proxy.resource;
    }

    /**
     * gets a resource from the pool
     * waits for as long as the timeout
     * specifies, use zero if you don't
     * want to wait at all
     */
    public Object get(long timeout) {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        if (timeout == 0) return null;

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(timeout);
        return proxy.resource;
    }

    /**
     * releases a resource back to the pool
     * returns false if the specified resource was released
     */
    public boolean release(Object resource) {
        synchronized (this) {
            if (unavailable.remove(resource))
                available.add(resource);
            else
                return false;
        }

        synchronized (this) {
            while (available.size() > 0 && queue.size() > 0) {
                Proxy proxy = (Proxy)queue.removeFirst();
                proxy.resource = available.removeFirst();
                unavailable.add(proxy.resource);
                proxy.wake();
            }
        }

        return true;
    }
}package com.iname.andrewcottrell.util;

import java.util.LinkedList;

public class Pool {

    private static class Proxy {
        public Object resource;
        public void sleep(long timeout) {
               synchronized(this){
                   try {wait(timeout);}
                   catch (InterruptedException e) {}
               }
        }
        public void wake() {
               synchronized(this){
                   notifyAll();
               }
        }
        public String toString() {
            return "p";
        }
    }

    private LinkedList queue;
    private LinkedList available;
    private LinkedList unavailable;

    /** size of queue */
    public synchronized int queue() {
        return queue.size();
    }

    /** size of available */
    public synchronized int available() {
        return available.size();
    }

    /** size of unavailable */
    public synchronized int unavailable() {
        return unavailable.size();
    }

    /** size of total */
    public synchronized int total() {
        return available() + unavailable();
    }

    /**
     * Consutructs new Pool object
     */
    public Pool() {
        queue       = new LinkedList();
        available   = new LinkedList();
        unavailable = new LinkedList();
    }

    /**
     * adds new resource to the pool
     * returns true if the specified resource was added
     */
    public synchronized boolean add(Object resource) {
        if (
            resource == null ||
            available.contains(resource) ||
            unavailable.contains(resource)
        ) return false;
        return available.add(resource);
    }

    /**
     * removes a resource from the pool
     * the resource must have been checked
     * out of the pool
     * returns true if the specified resource was removed
     */
    public synchronized boolean remove(Object resource) {
        if (!unavailable.remove(resource)) return false;
        return true;
    }

    /**
     * gets a resource from the pool
     * waits until a free resource is
     * available
     */
    public Object get() {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(0);
        return proxy.resource;
    }

    /**
     * gets a resource from the pool
     * waits for as long as the timeout
     * specifies, use zero if you don't
     * want to wait at all
     */
    public Object get(long timeout) {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        if (timeout == 0) return null;

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(timeout);
        return proxy.resource;
    }

    /**
     * releases a resource back to the pool
     * returns false if the specified resource was released
     */
    public boolean release(Object resource) {
        synchronized (this) {
            if (unavailable.remove(resource))
                available.add(resource);
            else
                return false;
        }

        synchronized (this) {
            while (available.size() > 0 && queue.size() > 0) {
                Proxy proxy = (Proxy)queue.removeFirst();
                proxy.resource = available.removeFirst();
                unavailable.add(proxy.resource);
                proxy.wake();
            }
        }

        return true;
    }
}package com.iname.andrewcottrell.util;

import java.util.LinkedList;

public class Pool {

    private static class Proxy {
        public Object resource;
        public void sleep(long timeout) {
               synchronized(this){
                   try {wait(timeout);}
                   catch (InterruptedException e) {}
               }
        }
        public void wake() {
               synchronized(this){
                   notifyAll();
               }
        }
        public String toString() {
            return "p";
        }
    }

    private LinkedList queue;
    private LinkedList available;
    private LinkedList unavailable;

    /** size of queue */
    public synchronized int queue() {
        return queue.size();
    }

    /** size of available */
    public synchronized int available() {
        return available.size();
    }

    /** size of unavailable */
    public synchronized int unavailable() {
        return unavailable.size();
    }

    /** size of total */
    public synchronized int total() {
        return available() + unavailable();
    }

    /**
     * Consutructs new Pool object
     */
    public Pool() {
        queue       = new LinkedList();
        available   = new LinkedList();
        unavailable = new LinkedList();
    }

    /**
     * adds new resource to the pool
     * returns true if the specified resource was added
     */
    public synchronized boolean add(Object resource) {
        if (
            resource == null ||
            available.contains(resource) ||
            unavailable.contains(resource)
        ) return false;
        return available.add(resource);
    }

    /**
     * removes a resource from the pool
     * the resource must have been checked
     * out of the pool
     * returns true if the specified resource was removed
     */
    public synchronized boolean remove(Object resource) {
        if (!unavailable.remove(resource)) return false;
        return true;
    }

    /**
     * gets a resource from the pool
     * waits until a free resource is
     * available
     */
    public Object get() {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(0);
        return proxy.resource;
    }

    /**
     * gets a resource from the pool
     * waits for as long as the timeout
     * specifies, use zero if you don't
     * want to wait at all
     */
    public Object get(long timeout) {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        if (timeout == 0) return null;

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(timeout);
        return proxy.resource;
    }

    /**
     * releases a resource back to the pool
     * returns false if the specified resource was released
     */
    public boolean release(Object resource) {
        synchronized (this) {
            if (unavailable.remove(resource))
                available.add(resource);
            else
                return false;
        }

        synchronized (this) {
            while (available.size() > 0 && queue.size() > 0) {
                Proxy proxy = (Proxy)queue.removeFirst();
                proxy.resource = available.removeFirst();
                unavailable.add(proxy.resource);
                proxy.wake();
            }
        }

        return true;
    }
}package com.iname.andrewcottrell.util;

import java.util.LinkedList;

public class Pool {

    private static class Proxy {
        public Object resource;
        public void sleep(long timeout) {
               synchronized(this){
                   try {wait(timeout);}
                   catch (InterruptedException e) {}
               }
        }
        public void wake() {
               synchronized(this){
                   notifyAll();
               }
        }
        public String toString() {
            return "p";
        }
    }

    private LinkedList queue;
    private LinkedList available;
    private LinkedList unavailable;

    /** size of queue */
    public synchronized int queue() {
        return queue.size();
    }

    /** size of available */
    public synchronized int available() {
        return available.size();
    }

    /** size of unavailable */
    public synchronized int unavailable() {
        return unavailable.size();
    }

    /** size of total */
    public synchronized int total() {
        return available() + unavailable();
    }

    /**
     * Consutructs new Pool object
     */
    public Pool() {
        queue       = new LinkedList();
        available   = new LinkedList();
        unavailable = new LinkedList();
    }

    /**
     * adds new resource to the pool
     * returns true if the specified resource was added
     */
    public synchronized boolean add(Object resource) {
        if (
            resource == null ||
            available.contains(resource) ||
            unavailable.contains(resource)
        ) return false;
        return available.add(resource);
    }

    /**
     * removes a resource from the pool
     * the resource must have been checked
     * out of the pool
     * returns true if the specified resource was removed
     */
    public synchronized boolean remove(Object resource) {
        if (!unavailable.remove(resource)) return false;
        return true;
    }

    /**
     * gets a resource from the pool
     * waits until a free resource is
     * available
     */
    public Object get() {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(0);
        return proxy.resource;
    }

    /**
     * gets a resource from the pool
     * waits for as long as the timeout
     * specifies, use zero if you don't
     * want to wait at all
     */
    public Object get(long timeout) {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        if (timeout == 0) return null;

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(timeout);
        return proxy.resource;
    }

    /**
     * releases a resource back to the pool
     * returns false if the specified resource was released
     */
    public boolean release(Object resource) {
        synchronized (this) {
            if (unavailable.remove(resource))
                available.add(resource);
            else
                return false;
        }

        synchronized (this) {
            while (available.size() > 0 && queue.size() > 0) {
                Proxy proxy = (Proxy)queue.removeFirst();
                proxy.resource = available.removeFirst();
                unavailable.add(proxy.resource);
                proxy.wake();
            }
        }

        return true;
    }
}package com.iname.andrewcottrell.util;

import java.util.LinkedList;

public class Pool {

    private static class Proxy {
        public Object resource;
        public void sleep(long timeout) {
               synchronized(this){
                   try {wait(timeout);}
                   catch (InterruptedException e) {}
               }
        }
        public void wake() {
               synchronized(this){
                   notifyAll();
               }
        }
        public String toString() {
            return "p";
        }
    }

    private LinkedList queue;
    private LinkedList available;
    private LinkedList unavailable;

    /** size of queue */
    public synchronized int queue() {
        return queue.size();
    }

    /** size of available */
    public synchronized int available() {
        return available.size();
    }

    /** size of unavailable */
    public synchronized int unavailable() {
        return unavailable.size();
    }

    /** size of total */
    public synchronized int total() {
        return available() + unavailable();
    }

    /**
     * Consutructs new Pool object
     */
    public Pool() {
        queue       = new LinkedList();
        available   = new LinkedList();
        unavailable = new LinkedList();
    }

    /**
     * adds new resource to the pool
     * returns true if the specified resource was added
     */
    public synchronized boolean add(Object resource) {
        if (
            resource == null ||
            available.contains(resource) ||
            unavailable.contains(resource)
        ) return false;
        return available.add(resource);
    }

    /**
     * removes a resource from the pool
     * the resource must have been checked
     * out of the pool
     * returns true if the specified resource was removed
     */
    public synchronized boolean remove(Object resource) {
        if (!unavailable.remove(resource)) return false;
        return true;
    }

    /**
     * gets a resource from the pool
     * waits until a free resource is
     * available
     */
    public Object get() {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(0);
        return proxy.resource;
    }

    /**
     * gets a resource from the pool
     * waits for as long as the timeout
     * specifies, use zero if you don't
     * want to wait at all
     */
    public Object get(long timeout) {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        if (timeout == 0) return null;

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(timeout);
        return proxy.resource;
    }

    /**
     * releases a resource back to the pool
     * returns false if the specified resource was released
     */
    public boolean release(Object resource) {
        synchronized (this) {
            if (unavailable.remove(resource))
                available.add(resource);
            else
                return false;
        }

        synchronized (this) {
            while (available.size() > 0 && queue.size() > 0) {
                Proxy proxy = (Proxy)queue.removeFirst();
                proxy.resource = available.removeFirst();
                unavailable.add(proxy.resource);
                proxy.wake();
            }
        }

        return true;
    }
}package com.iname.andrewcottrell.util;

import java.util.LinkedList;

public class Pool {

    private static class Proxy {
        public Object resource;
        public void sleep(long timeout) {
               synchronized(this){
                   try {wait(timeout);}
                   catch (InterruptedException e) {}
               }
        }
        public void wake() {
               synchronized(this){
                   notifyAll();
               }
        }
        public String toString() {
            return "p";
        }
    }

    private LinkedList queue;
    private LinkedList available;
    private LinkedList unavailable;

    /** size of queue */
    public synchronized int queue() {
        return queue.size();
    }

    /** size of available */
    public synchronized int available() {
        return available.size();
    }

    /** size of unavailable */
    public synchronized int unavailable() {
        return unavailable.size();
    }

    /** size of total */
    public synchronized int total() {
        return available() + unavailable();
    }

    /**
     * Consutructs new Pool object
     */
    public Pool() {
        queue       = new LinkedList();
        available   = new LinkedList();
        unavailable = new LinkedList();
    }

    /**
     * adds new resource to the pool
     * returns true if the specified resource was added
     */
    public synchronized boolean add(Object resource) {
        if (
            resource == null ||
            available.contains(resource) ||
            unavailable.contains(resource)
        ) return false;
        return available.add(resource);
    }

    /**
     * removes a resource from the pool
     * the resource must have been checked
     * out of the pool
     * returns true if the specified resource was removed
     */
    public synchronized boolean remove(Object resource) {
        if (!unavailable.remove(resource)) return false;
        return true;
    }

    /**
     * gets a resource from the pool
     * waits until a free resource is
     * available
     */
    public Object get() {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(0);
        return proxy.resource;
    }

    /**
     * gets a resource from the pool
     * waits for as long as the timeout
     * specifies, use zero if you don't
     * want to wait at all
     */
    public Object get(long timeout) {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        if (timeout == 0) return null;

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(timeout);
        return proxy.resource;
    }

    /**
     * releases a resource back to the pool
     * returns false if the specified resource was released
     */
    public boolean release(Object resource) {
        synchronized (this) {
            if (unavailable.remove(resource))
                available.add(resource);
            else
                return false;
        }

        synchronized (this) {
            while (available.size() > 0 && queue.size() > 0) {
                Proxy proxy = (Proxy)queue.removeFirst();
                proxy.resource = available.removeFirst();
                unavailable.add(proxy.resource);
                proxy.wake();
            }
        }

        return true;
    }
}
</code>

[Andrew Cottrell]

The following code implements the same sort of idea, but doesn't impose on the Pool Manager

The idea is you'd create a Pool Manager (no interface to implement) to do the following

* create a Pool object
* add resources to the pool
* remove resources from the pool

I guess the Pool Manager would often be a singlton. The obvious example would be a DatabaseConnectionManager for a JSP/Servlet website.

package com.iname.andrewcottrell.util;

import java.util.LinkedList;

public class Pool {

    private static class Proxy {
        public Object resource;
        public void sleep(long timeout) {
               synchronized(this){
                   try {wait(timeout);}
                   catch (InterruptedException e) {}
               }
        }
        public void wake() {
               synchronized(this){
                   notifyAll();
               }
        }
        public String toString() {
            return "p";
        }
    }

    private LinkedList queue;
    private LinkedList available;
    private LinkedList unavailable;

    /** size of queue */
    public synchronized int queue() {
        return queue.size();
    }

    /** size of available */
    public synchronized int available() {
        return available.size();
    }

    /** size of unavailable */
    public synchronized int unavailable() {
        return unavailable.size();
    }

    /** size of total */
    public synchronized int total() {
        return available() + unavailable();
    }

    /**
     * Consutructs new Pool object
     */
    public Pool() {
        queue       = new LinkedList();
        available   = new LinkedList();
        unavailable = new LinkedList();
    }

    /**
     * adds new resource to the pool
     * returns true if the specified resource was added
     */
    public synchronized boolean add(Object resource) {
        if (
            resource == null ||
            available.contains(resource) ||
            unavailable.contains(resource)
        ) return false;
        return available.add(resource);
    }

    /**
     * removes a resource from the pool
     * the resource must have been checked
     * out of the pool
     * returns true if the specified resource was removed
     */
    public synchronized boolean remove(Object resource) {
        if (!unavailable.remove(resource)) return false;
        return true;
    }

    /**
     * gets a resource from the pool
     * waits until a free resource is
     * available
     */
    public Object get() {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(0);
        return proxy.resource;
    }

    /**
     * gets a resource from the pool
     * waits for as long as the timeout
     * specifies, use zero if you don't
     * want to wait at all
     */
    public Object get(long timeout) {
        synchronized (this) {
            if (queue.size() == 0 && available.size() > 0) {
                Object resource = available.removeFirst();
                unavailable.add(resource);
                return resource;
            }
        }

        if (timeout == 0) return null;

        Proxy proxy = new Proxy();
        queue.add(proxy);
        proxy.sleep(timeout);
        return proxy.resource;
    }

    /**
     * releases a resource back to the pool
     * returns false if the specified resource was released
     */
    public boolean release(Object resource) {
        synchronized (this) {
            if (unavailable.remove(resource))
                available.add(resource);
            else
                return false;
        }

        synchronized (this) {
            while (available.size() > 0 && queue.size() > 0) {
                Proxy proxy = (Proxy)queue.removeFirst();
                proxy.resource = available.removeFirst();
                unavailable.add(proxy.resource);
                proxy.wake();
            }
        }

        return true;
    }
}