Problem in Filling Pool, In ConnectionPooling Code:Urgent Plz

Question

Hi All,
I m using this program for Connection Pooling.
import java.sql.*;
import javax.sql.*;
import java.util.*;
import java.io.*;
import javax.naming.*;
public class ConnectionPool implements Runnable{
  private DataSource datasource;
  private int maxConnections;
  private int initialConnections;
  private boolean waitIfBusy;
  private boolean connectionPending = false;
  private Vector<java.sql.Connection> availableConnections;
  private Vector<java.sql.Connection> busyConnections;
  public ConnectionPool()throws SQLException {
    try{
         Context ic = new InitialContext();
          this.datasource = (DataSource)ic.lookup("java:msgds");                    
          System.out.println("DataSource Found msgds");
     }catch(Exception e){
          System.out.println("Error in ConnectionPool COnstructor While Locatin ashishds");
    this.waitIfBusy = true;   
    this.waitIfBusy = waitIfBusy;
    this.maxConnections = 5;
    this.initialConnections = 2;
    availableConnections = new Vector<java.sql.Connection>(2);
    busyConnections = new Vector<java.sql.Connection>();
    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 {    
      // Establish network connection to database
      Connection connection = datasource.getConnection();
      return(connection);
    } catch(Exception cnfe) {
      // Simplify try/catch blocks of people using this by
      // throwing only one exception type.
      throw new SQLException("Error in makeNewConnection() : " +cnfe);
  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<java.sql.Connection>();
    closeConnections(busyConnections);
    busyConnections = new Vector<java.sql.Connection>();
  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(Data Source is :"+datasource+ ")" +
      ", available=" + availableConnections.size() +
      ", busy=" + busyConnections.size() +
      ", max=" + maxConnections;
    return(info);
}To Test This code, I had created one Servlet. In This Servlet I m calling like this:
in
init(){
     connectionPool = new ConnectionPool();
}in
in
service(){
     private ConnectionPool connectionPool=null;
     connection = connectionPool.getConnection();
}in destroy of
destroy{
     if(connectionPool != null){
              connectionPool.closeAllConnections();     
}The Problem is that, Many a times it work, many a times it shows following Error:
09:56:35,109 WARN  [JBossManagedConnectionPool] Unable to fill pool
org.jboss.resource.JBossResourceException: Could not create connection; - nested throwable: (java.sql.SQLException:
Listener refused the connection with the following error:
ORA-12516, TNS:listener could not find available handler with matching protocol stack
The Connection descriptor used by the client was:
192.168.1.8:1521
        at org.jboss.resource.adapter.jdbc.local.LocalManagedConnectionFactory.createManagedConnection(LocalManagedConnectionFa
ctory.java:177)
        at org.jboss.resource.connectionmanager.InternalManagedConnectionPool.createConnectionEventListener(InternalManagedConn
ectionPool.java:539)
        at org.jboss.resource.connectionmanager.InternalManagedConnectionPool.fillToMin(InternalManagedConnectionPool.java:486)
        at org.jboss.resource.connectionmanager.PoolFiller.run(PoolFiller.java:74)
        at java.lang.Thread.run(Thread.java:595)
Caused by: java.sql.SQLException: Listener refused the connection with the following error:
ORA-12516, TNS:listener could not find available handler with matching protocol stack
The Connection descriptor used by the client was:
192.168.1.8:1521
        at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:112)
        at oracle.jdbc.driver.DatabaseError.throwSqlException(DatabaseError.java:261)
        at oracle.jdbc.driver.T4CConnection.logon(T4CConnection.java:387)
        at oracle.jdbc.driver.PhysicalConnection.<init>(PhysicalConnection.java:414)
        at oracle.jdbc.driver.T4CConnection.<init>(T4CConnection.java:165)
        at oracle.jdbc.driver.T4CDriverExtension.getConnection(T4CDriverExtension.java:35)
        at oracle.jdbc.driver.OracleDriver.connect(OracleDriver.java:801)
        at org.jboss.resource.adapter.jdbc.local.LocalManagedConnectionFactory.createManagedConnection(LocalManagedConnectionFa
ctory.java:169)
        ... 4 moreI M using JBoss 4.0, With OracleXE. I had defined my DataSource-> msgds in mydb-ds.xml of deploy folder of JBoss.
which is like this:
<?xml version="1.0" encoding="UTF-8"?>
<datasources>
  <local-tx-datasource>
    <jndi-name>msgds</jndi-name>
    <connection-url>jdbc:oracle:thin:@192.168.1.8:1521</connection-url>   
    <driver-class>oracle.jdbc.OracleDriver</driver-class>
    <!-- The login and password -->
    <user-name>ashish</user-name>
    <password>ashish</password>
    <min-pool-size>5</min-pool-size>
    <max-pool-size>100</max-pool-size>
    <idle-timeout-minutes>0</idle-timeout-minutes>
  </local-tx-datasource>
</datasources>I want to know whether This is a right approach to do Connection Pooling. How can I implement this Using Commons.
What changes i need to made in my mydb-ds.xml if I use Commons Package and also in the code.

Answer 1

never ask for help to be sent to your email, always post in this thread so that if someone else has the same question they can get the help too.
this should help get you started... just make sure you get the apache dbcp package (you may need some commons things too, like commons pool)
private BasicDataSource dataSource;
* This function actually initializes the datasource, which is
* in charge of setting up the BasicDataSource, which handles
* all the database pooling.
protected synchronized void initDataSource() {
     loadProperties(); // this loads my database properties from a config file
     try {
          dataSource = new BasicDataSource();
          dataSource.setDefaultAutoCommit(true);
          dataSource.setDefaultCatalog(catalogName);
          dataSource.setDriverClassName(jdbcDriver);
          dataSource.setUsername(jdbcUserID);
          dataSource.setPassword(jdbcPassword);
          dataSource.setUrl(jdbcURL);
          dataSource.setMinIdle(minCons);
          dataSource.setMaxIdle(maxCons);
          dataSource.setMaxActive(maxCons);
          dataSource.setMaxWait(5000); // milliseconds to wait for connection if none are available
          dataSource.setAccessToUnderlyingConnectionAllowed(true);
          // will validate each connection before handing it out
          dataSource.setTestOnBorrow(true);
          dataSource.setValidationQuery("select getDate()");
          // setup to test idle objects in the pool
          dataSource.setTestWhileIdle(true);
          dataSource.setTimeBetweenEvictionRunsMillis(600000); // run every 10 minutes
          dataSource.setMinEvictableIdleTimeMillis(60000);  // only examine connections idle for more than 10 minutes
          dataSource.setNumTestsPerEvictionRun(-3); // when this is negative one Nth of connections will be examined
     } catch (Exception e) {
          //whatever you want
public Connection getConnection() {
     try {
          Connection con = dataSource.getConnection();
          if(con == null) {
               throw new Exception("Error: DataSource gave a null connection object");
          return con;
     } catch (Exception e) {
          // whatever
public void freeConnection(Connection con) {
     freeConnection(con, false);
public void freeConnection(Connection con, boolean isError) {
     try {
          if(con == null) return;
          if(!con.isClosed()) {
               if(isError && !con.getAutoCommit()) {
                    con.rollback();
               con.clearWarnings();
               con.close(); // this adds the con back to the pool
     } catch(Exception e) {
          // whatever
}