src/org/objectweb/cjdbc/controller/connection/VariablePoolConnectionManager.java

説明を見る。

package org.objectweb.cjdbc.controller.connection;

import java.io.Serializable;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.EmptyStackException;
import java.util.Iterator;
import java.util.Stack;

import org.objectweb.cjdbc.common.exceptions.UnreachableBackendException;
import org.objectweb.cjdbc.common.xml.DatabasesXmlTags;

public class VariablePoolConnectionManager extends
    AbstractPoolConnectionManager implements Serializable
{
  public static final int             DEFAULT_MAX_POOL_SIZE = 0;

  public static final int             DEFAULT_IDLE_TIMEOUT  = 0;

  public static final int             DEFAULT_WAIT_TIMEOUT  = 0;

  private int                         initPoolSize;

  private int                         minPoolSize;

  private int                         maxPoolSize;

  private int                         idleTimeout;

  private int                         waitTimeout;

  private Stack                       releaseTimes;

  private RemoveIdleConnectionsThread removeIdleConnectionsThread;

  public VariablePoolConnectionManager(String backendUrl, String backendName,
      String rLogin, String rPassword, String driverPath,
      String driverClassName, int minPoolSize, int maxPoolSize,
      int idleTimeout, int waitTimeout)
  {
    this(backendUrl, backendName, rLogin, rPassword, driverPath,
        driverClassName, minPoolSize, minPoolSize, maxPoolSize, idleTimeout,
        waitTimeout);
  }

  protected Object clone() throws CloneNotSupportedException
  {
    return new VariablePoolConnectionManager(backendUrl, backendName, rLogin,
        rPassword, driverPath, driverClassName, minPoolSize, maxPoolSize,
        idleTimeout, waitTimeout);
  }

  public VariablePoolConnectionManager(String backendUrl, String backendName,
      String rLogin, String rPassword, String driverPath,
      String driverClassName, int initPoolSize, int minPoolSize,
      int maxPoolSize, int idleTimeout, int waitTimeout)
  {
    super(backendUrl, backendName, rLogin, rPassword, driverPath,
        driverClassName, maxPoolSize == 0 ? (initPoolSize > minPoolSize
            ? initPoolSize
            : minPoolSize) : maxPoolSize);
    this.initPoolSize = initPoolSize;
    this.minPoolSize = minPoolSize;
    this.maxPoolSize = maxPoolSize;
    this.idleTimeout = idleTimeout * 1000;
    this.waitTimeout = waitTimeout * 1000;
  }

  public int getMaxPoolSize()
  {
    return maxPoolSize;
  }

  public int getMinPoolSize()
  {
    return minPoolSize;
  }

  public int getIdleTimeout()
  {
    return idleTimeout;
  }

  public int getWaitTimeout()
  {
    return waitTimeout;
  }

  public synchronized void initializeConnections() throws SQLException
  {
    super.initializeConnections(initPoolSize);

    if (idleTimeout != 0)
    {
      // Create the thread which manages the free connections
      removeIdleConnectionsThread = new RemoveIdleConnectionsThread(this.backendName);

      // Intialize release time for the initial connections if an idleTimeout
      // is set
      releaseTimes = new Stack();
      Iterator it = freeConnections.iterator();
      Long currentTime = new Long(System.currentTimeMillis());
      while (it.hasNext())
      {
        it.next();
        releaseTimes.push(currentTime);
      }

      // Start the thread
      removeIdleConnectionsThread.start();

      synchronized (removeIdleConnectionsThread)
      {
        if (releaseTimes.size() > 0)
        {
          removeIdleConnectionsThread.notify();
        }
      }
    }
  }

  public synchronized void finalizeConnections() throws SQLException
  {
    if (removeIdleConnectionsThread != null)
    {
      synchronized (removeIdleConnectionsThread)
      {
        removeIdleConnectionsThread.isKilled = true;
        idleTimeout = 0;
        removeIdleConnectionsThread.notify();
      }
      try
      {
        removeIdleConnectionsThread.join();
      }
      catch (InterruptedException e)
      {
      }
    }
    super.finalizeConnections();
  }

  public Connection getConnection() throws UnreachableBackendException
  {
    if (!initialized)
    {
      logger
          .error("Requesting a connection from a non-initialized connection manager");
      return null;
    }

    long lTimeout = waitTimeout;
    synchronized (freeConnections)
    {
      if (freeConnections.isEmpty())
      {
        if ((maxPoolSize == 0) || (activeConnections.size() < maxPoolSize))
        {
          Connection c = getConnectionFromDriver();
          if (c == null)
          {
            if (activeConnections.size() == 0)
            { // No connection active and backend unreachable, the backend
              // is probably dead
              logger
                  .error("Backend " + backendName + " is no more accessible.");
              throw new UnreachableBackendException();
            }
            // If it fails, just wait for a connection to be freed
            if (logger.isWarnEnabled())
              logger.warn("Failed to create new connection on backend '"
                  + backendName + "', waiting for a connection to be freed.");
          }
          else
          {
            freeConnections.add(c);
            if (idleTimeout != 0)
            {
              releaseTimes.add(new Long(System.currentTimeMillis()));
            }
            poolSize++;
          }
        }

        /*
         * We have to do a while loop() because there is a potential race here.
         * When freeConnections is notified in releaseConnection, a new thread
         * can take the lock on freeConnections before we wake up/reacquire the
         * lock on freeConnections. Therefore, we could wake up and have no
         * connection to take! We ensure that everything is correct with a while
         * statement and recomputing the timeout between 2 wakeup.
         */
        while (freeConnections.isEmpty())
        {
          // Wait
          try
          {
            if (lTimeout > 0)
            {
              long start = System.currentTimeMillis();
              // Convert seconds to milliseconds for wait call
              freeConnections.wait(waitTimeout);
              long end = System.currentTimeMillis();
              lTimeout -= end - start;
              if (lTimeout <= 0)
              {
                if (logger.isWarnEnabled())
                  logger.warn("Timeout expired for connection on backend '"
                      + backendName
                      + "', consider increasing pool size (current size is "
                      + poolSize + ") or timeout (current timeout is "
                      + (waitTimeout / 1000) + " seconds)");
                return null;
              }
            }
            else
            {
              freeConnections.wait();
            }
          }
          catch (InterruptedException e)
          {
            logger
                .error("Wait on freeConnections interrupted in VariablePoolConnectionManager");
            return null;
          }
        }
      }

      // Get the connection
      try
      {
        Connection c = (Connection) freeConnections.pop();
        if (idleTimeout != 0)
        {
          releaseTimes.pop();
        }
        activeConnections.add(c);
        return c;
      }
      catch (EmptyStackException e)
      {
        if (logger.isErrorEnabled())
          logger.error("Failed to get a connection on backend '" + backendName
              + "' but an idle connection was expected");
        return null;
      }
    }
  }

  public void releaseConnection(Connection c)
  {
    if (!initialized)
      return; // We probably have been disabled

    boolean notifyThread = false;
    synchronized (freeConnections)
    {
      if (activeConnections.remove(c))
      {
        if (idleTimeout != 0)
        {
          notifyThread = freeConnections.isEmpty()
              || (freeConnections.size() == minPoolSize);
          freeConnections.push(c);
          freeConnections.notify();
          releaseTimes.push(new Long(System.currentTimeMillis()));
        }
        else
        {
          freeConnections.push(c);
          freeConnections.notify();
        }
      }
      else
        logger.error("Failed to release connection " + c
            + " (not found in active pool)");
    }

    if (notifyThread)
      synchronized (removeIdleConnectionsThread)
      {
        removeIdleConnectionsThread.notify();
      }
  }

  public void deleteConnection(Connection c)
  {
    if (!initialized)
      return; // We probably have been disabled

    synchronized (freeConnections)
    {
      if (activeConnections.remove(c))
      {
        poolSize--;
        if (poolSize < minPoolSize)
        {
          Connection newConnection = getConnectionFromDriver();
          if (newConnection == null)
          {
            if (logger.isDebugEnabled())
              logger.error("Bad connection " + c
                  + " has been removed but cannot be replaced.");
          }
          else
          {
            freeConnections.push(newConnection);
            freeConnections.notify();
            if (logger.isDebugEnabled())
              logger.debug("Bad connection " + c
                  + " has been replaced by a new connection.");
          }
        }
        else if (logger.isDebugEnabled())
          logger.debug("Bad connection " + c + " has been removed.");
      }
      else
        logger.error("Failed to release connection " + c
            + " (not found in active pool)");
    }
  }

  public String getXmlImpl()
  {
    StringBuffer info = new StringBuffer();
    info.append("<" + DatabasesXmlTags.ELT_VariablePoolConnectionManager + " "
        + DatabasesXmlTags.ATT_initPoolSize + "=\"" + initPoolSize + "\" "
        + DatabasesXmlTags.ATT_minPoolSize + "=\"" + minPoolSize + "\" "
        + DatabasesXmlTags.ATT_maxPoolSize + "=\"" + maxPoolSize + "\" "
        + DatabasesXmlTags.ATT_idleTimeout + "=\"" + idleTimeout / 1000 + "\" "
        + DatabasesXmlTags.ATT_waitTimeout + "=\"" + waitTimeout / 1000
        + "\"/>");
    return info.toString();
  }

  protected class RemoveIdleConnectionsThread extends Thread
  {
    private boolean isKilled = false;

    protected RemoveIdleConnectionsThread(String pBackendName)
    {
      super("RemoveIdleConnectionsThread for backend:" + pBackendName);
    }

    public void run()
    {
      long idleTime, releaseTime;
      synchronized (this)
      {
        try
        {
          while (!isKilled)
          {
            // the thread is not launched if idleTimeout equals to 0 (the
            // connections are never released in this case)
            if (freeConnections.isEmpty()
                || (freeConnections.size() == minPoolSize))
            {
              wait();
            }

            Connection c = null;
            synchronized (freeConnections)
            {
              if (releaseTimes.isEmpty())
                continue; // Sanity check

              releaseTime = ((Long) releaseTimes.get(0)).longValue();
              idleTime = System.currentTimeMillis() - releaseTime;

              if (idleTime >= idleTimeout)
                c = (Connection) freeConnections.remove(0);
            }

            if (c == null)
            { // Nothing to free, wait for next deadline
              wait(idleTimeout - idleTime);
            }
            else
            { // Free the connection out of the synchronized block
              try
              {
                c.close();
              }
              catch (SQLException e)
              {
                String msg = "An error occured while closing idle connection after the timeout: "
                    + e;
                logger.error(msg);
              }
              finally
              {
                releaseTimes.remove(0);
                poolSize--;
              }
              logger.debug("Released idle connection (idle timeout reached)");
              continue;

            }
          }
        }
        catch (InterruptedException e)
        {
          logger
              .error("Wait on removeIdleConnectionsThread interrupted in VariablePoolConnectionManager: "
                  + e);
        }
      }
    }
  }

}

---