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

説明を見る。

package org.objectweb.cjdbc.controller.connection;

import java.io.Serializable;
import java.sql.Connection;
import java.util.EmptyStackException;

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

public class RandomWaitPoolConnectionManager
    extends
      AbstractPoolConnectionManager implements Serializable
{
  private int timeout;

  public RandomWaitPoolConnectionManager(String backendUrl, String backendName,
      String login, String password, String driverPath, String driverClassName,
      int poolSize, int timeout)
  {
    super(backendUrl, backendName, login, password, driverPath,
        driverClassName, poolSize);
    this.timeout = timeout * 1000;
  }
  
  protected Object clone() throws CloneNotSupportedException
  {
    return new RandomWaitPoolConnectionManager(backendUrl, backendName, rLogin,
        rPassword, driverPath, driverClassName, poolSize,timeout);
  }

  public int getTimeout()
  {
    return timeout;
  }

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

    long lTimeout = timeout;
    synchronized (freeConnections)
    {
      // 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(timeout);
            long end = System.currentTimeMillis();
            lTimeout -= end - start;
            if (lTimeout <= 0)
            {
              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 (logger.isWarnEnabled())
                logger.warn("Timeout expired for connection on backend '"
                    + backendName
                    + "', consider increasing pool size (current size is "
                    + poolSize + ") or timeout (current timeout is "
                    + (timeout / 1000) + " seconds)");
              return null;
            }
          }
          else
            freeConnections.wait();
        }
        catch (InterruptedException e)
        {
          logger
              .error("Wait on freeConnections interrupted in RandomWaitPoolConnectionManager: "
                  + e);
          return null;
        }
      }
      // Get the connection
      try
      {
        Connection c = (Connection) freeConnections.pop();
        activeConnections.add(c);
        return c;
      }
      catch (EmptyStackException e)
      {
        int missing = poolSize
            - (activeConnections.size() + freeConnections.size());
        if (missing > 0)
        { // Re-allocate missing connections
          logger.info("Trying to reallocate " + missing
              + " missing connections.");
          Connection connectionToBeReturned = null;
          while (missing > 0)
          {
            Connection c = getConnectionFromDriver();
            if (c == null)
            {
              if (missing == poolSize)
              {
                String msg = Translate.get("loadbalancer.backend.unreacheable",
                    backendName);
                logger.error(msg);
                throw new UnreachableBackendException(msg);
              }
              logger.warn("Unable to re-allocate " + missing
                  + " missing connections.");
              break;
            }
            else
            {
              if (connectionToBeReturned == null)
                connectionToBeReturned = c;
              else
                freeConnections.add(c);
            }
            missing--;
          }
          return connectionToBeReturned;
        }
        if (logger.isErrorEnabled())
          logger.error("Failed to get a connection on backend '" + backendName
              + "' whereas an idle connection was expected");
        return null;
      }
    }
  }

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

    synchronized (freeConnections)
    {
      if (activeConnections.remove(c))
      {
        freeConnections.push(c);
        freeConnections.notify();
      }
      else
        logger.error("Failed to release connection " + c
            + " (not found in active pool)");
    }
  }

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

    synchronized (freeConnections)
    {
      if (activeConnections.remove(c))
      {
        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
        logger.error("Failed to release connection " + c
            + " (not found in active pool)");
    }
  }

  public String getXmlImpl()
  {
    StringBuffer info = new StringBuffer();
    info.append("<" + DatabasesXmlTags.ELT_RandomWaitPoolConnectionManager
        + " " + DatabasesXmlTags.ATT_poolSize + "=\"" + poolSize + "\" "
        + DatabasesXmlTags.ATT_timeout + "=\"" + timeout / 1000 + "\"/>");
    return info.toString();
  }

}

---