I've the following code which I am using to implement a pool of database connection pools ( our development environment needs each of our developers to have their own db pool - it's a long story.... )

Anyway, what I thought would happen is that as the applications make calls to DatabasePoolFactory.getInstance(...) I would create one and only one hashtable and put and get poolmanager objects from it. Here's the code:

package BslDatabasePool;

import java.util.*;
import SPAR.BslException.*;

public class BslDatabasePoolFactory
{

    static private Hashtable dbList = null;

/**
 * Retrieves an instance of the named PoolManager. This should be used when you
 * want to connect to a pool which you know ( or hope! )to be available, and you don't want to
 * go to the trouble of having to define the db context. If the Pool is actually
 * NOT running, then an UnknownPoolException is thrown.
 */
    static public synchronized PoolManager getInstance(String PoolName) throws Exception
    {
       return getInstance(PoolName,(SparDatabaseContext)null);
    }
   
/**
 * Retrieves an instance of the named PoolManager, creating a new one with
 * the supplied name and database context if one does not already exist. If
 * a pool manager exists with the specified name, YOU WILL BE RETURNED A
 * REFERENCE TO IT REGARDLESS OF WHETHER OR NOT ITS CONTEXT MATCHES THAT
 * WHICH YOU PASSED IN. This means that there is a possibility that you
 * may end up connecting to a database that you don't want to. Making sure
 * that this doesn't happen is dependent upon sensible naming standards.
 */
    static public synchronized PoolManager getInstance(String PoolName,
                                                       SparDatabaseContext SdbC)
                                                       throws Exception,
                                                              UnknownPool
    {

        if (dbList == null)
        {
            System.out.println("Creating New Database Factory");
            dbList = new Hashtable();
        }

        PoolManager tmp = (PoolManager)dbList.get(PoolName);

        if (tmp == null)
        {
            System.out.println("PoolManager Not Found - Creating New One called " + PoolName);
            if (SdbC == null)
            {
                throw(new UnknownPool(PoolName));
            }
            tmp = new PoolManager(SdbC);
            tmp.setName(PoolName);
            dbList.put(PoolName,tmp);
        }
         else {System.out.println("Pool Already Available");};

        return tmp;

    }

}

My understanding of static ( which I'm sure is wrong! ) is such that, as the first call on the static getInstance method is received, a dbList hashtable will be created and the message "Creating New Database Factory" will be produced. After that, any subsequent calls to getInstance will go to the hashtable and retrieve the specified poolmanager object. This appears to happen as long as only one tomcat servlet is running. When a second servlet calls getInstance, I would expect it to see that the static hashtable dbList is already in existence and just put any new pool manager instances in to the same hashtable. What _actually_ happens is that I see another "Creating New Database Factory" message, which I guess means that a new hash table is being created and populated.

My understanding was that a static class would exist once in the JVM. This doesn't appear to be happening. Where is my understanding letting me down?

Dave