Source code: org/roller/util/ConnectionPool.java

   
   package org.roller.util;
   
   import java.sql.*;
   import java.util.*;
   
   /** A class for preallocating, recycling, and managing
    *  JDBC connections.
    *  <P>
   *  Taken from Core Servlets and JavaServer Pages
   *  from Prentice Hall and Sun Microsystems Press,
   *  http://www.coreservlets.com/.
   *  &copy; 2000 Marty Hall; may be freely used or adapted.
   */
  
  public class ConnectionPool implements Runnable {
    private String driver, url, username, password;
    private int maxConnections;
    private boolean waitIfBusy;
    private Vector availableConnections, busyConnections;
    private boolean connectionPending = false;
  
    public ConnectionPool(String driver, String url,
                          String username, String password,
                          int initialConnections,
                          int maxConnections,
                          boolean waitIfBusy)
        throws SQLException {
      this.driver = driver;
      this.url = url;
      this.username = username;
      this.password = password;
      this.maxConnections = maxConnections;
      this.waitIfBusy = waitIfBusy;
      if (initialConnections > maxConnections) {
        initialConnections = maxConnections;
      }
      availableConnections = new Vector(initialConnections);
      busyConnections = new Vector();
      for(int i=0; i<initialConnections; i++) {
        availableConnections.addElement(makeNewConnection());
      }
    }
    
    public synchronized Connection getConnection()
        throws SQLException {
      if (!availableConnections.isEmpty()) {
        Connection existingConnection =
          (Connection)availableConnections.lastElement();
        int lastIndex = availableConnections.size() - 1;
        availableConnections.removeElementAt(lastIndex);
        // If connection on available list is closed (e.g.,
        // it timed out), then remove it from available list
        // and repeat the process of obtaining a connection.
        // Also wake up threads that were waiting for a
        // connection because maxConnection limit was reached.
        if (existingConnection.isClosed()) {
          notifyAll(); // Freed up a spot for anybody waiting
          return(getConnection());
        } else {
          busyConnections.addElement(existingConnection);
          return(existingConnection);
        }
      } else {
        
        // Three possible cases:
        // 1) You haven't reached maxConnections limit. So
        //    establish one in the background if there isn't
        //    already one pending, then wait for
        //    the next available connection (whether or not
        //    it was the newly established one).
        // 2) You reached maxConnections limit and waitIfBusy
        //    flag is false. Throw SQLException in such a case.
        // 3) You reached maxConnections limit and waitIfBusy
        //    flag is true. Then do the same thing as in second
        //    part of step 1: wait for next available connection.
        
        if ((totalConnections() < maxConnections) &&
            !connectionPending) {
          makeBackgroundConnection();
        } else if (!waitIfBusy) {
          throw new SQLException("Connection limit reached");
        }
        // Wait for either a new connection to be established
        // (if you called makeBackgroundConnection) or for
        // an existing connection to be freed up.
        try {
          wait();
        } catch(InterruptedException ie) {}
        // Someone freed up a connection, so try again.
        return(getConnection());
      }
    }
  
    // You can't just make a new connection in the foreground
    // when none are available, since this can take several
    // seconds with a slow network connection. Instead,
    // start a thread that establishes a new connection,
    // then wait. You get woken up either when the new connection
   // is established or if someone finishes with an existing
   // connection.
 
   private void makeBackgroundConnection() {
     connectionPending = true;
     try {
       Thread connectThread = new Thread(this);
       connectThread.start();
     } catch(OutOfMemoryError oome) {
       // Give up on new connection
     }
   }
 
   public void run() {
     try {
       Connection connection = makeNewConnection();
       synchronized(this) {
         availableConnections.addElement(connection);
         connectionPending = false;
         notifyAll();
       }
     } catch(Exception e) { // SQLException or OutOfMemory
       // Give up on new connection and wait for existing one
       // to free up.
     }
   }
 
   // This explicitly makes a new connection. Called in
   // the foreground when initializing the ConnectionPool,
   // and called in the background when running.
   
   private Connection makeNewConnection()
       throws SQLException {
     try {
       // Load database driver if not already loaded
       Class.forName(driver);
       // Establish network connection to database
       Connection connection =
         DriverManager.getConnection(url, username, password);
       return(connection);
     } catch(ClassNotFoundException cnfe) {
       // Simplify try/catch blocks of people using this by
       // throwing only one exception type.
       throw new SQLException("Can't find class for driver: " +
                              driver);
     }
   }
 
   public synchronized void free(Connection connection) {
     busyConnections.removeElement(connection);
     availableConnections.addElement(connection);
     // Wake up threads that are waiting for a connection
     notifyAll(); 
   }
     
   public synchronized int totalConnections() {
     return(availableConnections.size() +
            busyConnections.size());
   }
 
   /** Close all the connections. Use with caution:
    *  be sure no connections are in use before
    *  calling. Note that you are not <I>required</I> to
    *  call this when done with a ConnectionPool, since
    *  connections are guaranteed to be closed when
    *  garbage collected. But this method gives more control
    *  regarding when the connections are closed.
    */
 
   public synchronized void closeAllConnections() {
     closeConnections(availableConnections);
     availableConnections = new Vector();
     closeConnections(busyConnections);
     busyConnections = new Vector();
   }
 
   private void closeConnections(Vector connections) {
     try {
       for(int i=0; i<connections.size(); i++) {
         Connection connection =
           (Connection)connections.elementAt(i);
         if (!connection.isClosed()) {
           connection.close();
         }
       }
     } catch(SQLException sqle) {
       // Ignore errors; garbage collect anyhow
     }
   }
   
   public synchronized String toString() {
     String info =
       "ConnectionPool(" + url + "," + username + ")" +
       ", available=" + availableConnections.size() +
       ", busy=" + busyConnections.size() +
       ", max=" + maxConnections;
     return(info);
   }
 }