Metacat

                  Integer.parseInt(MetaCatUtil.getOption("maximumUsageNumber"));

  //the parameter if run dbconncestionrecyclethread or not

  final static String DBCONNECTIONRECYCLETHREAD =

                          MetaCatUtil.getOption("runDBConnectionRecycleThread");

  //the cycle time of connection recycle action

  final static long CYCLETIMEOFDBCONNECTION = 

               Long.parseLong(MetaCatUtil.getOption("cycleTimeOfDBConnection"));

    MetaCatUtil.debugMessage

             ("Running recycle thread or not: "+DBCONNECTIONRECYCLETHREAD, 49);

    MetaCatUtil.debugMessage

             ("Cycle time of recycle: "+CYCLETIMEOFDBCONNECTION, 49); 

    if (DBCONNECTIONRECYCLETHREAD.equals("on"))

    {

      runner = new Thread(this);

      runner.start();

    }

  /**

   * Method to get a DBConnection in connection pool

   * 1) try to get a DBConnection from DBConnection pool

   * 2) if 1) failed, then check the size of pool. If the size reach the

   *    maximum number of connection, throw a exception: couldn't get one

   * 3) If the size is less than the maximum number of connectio, create some

   *    new connections and recursive get one

   * @param methodName, the name of method which will check connection out

   */

  public static synchronized DBConnection getDBConnection(String methodName) 

                                                throws SQLException

  {

    DBConnection db = null;

    MetaCatUtil.debugMessage("Try to checking out connection...", 10);    

    //try every DBConnection in the pool

      for (int i=0; i<connectionPool.size(); i++)

      {

        db = (DBConnection) connectionPool.elementAt(i);

        //check if the connection is free

        if (db.getStatus()==FREE)

        {

          //If this connection is good, return this DBConnection

          if (validateDBConnection(db))

          {

            //set this DBConnection status

            db.setStatus(BUSY);

            //increase one usageCount

            db.increaseUsageCount(1);

            //set method name to DBConnection

            db.setCheckOutMethodName(methodName);

            //debug message

            MetaCatUtil.debugMessage("The connection is checked out: "

                                       +db.getTag(), 5);

            MetaCatUtil.debugMessage("The age is "+db.getAge(), 5);

            MetaCatUtil.debugMessage("The usage is "+db.getUsageCount(), 5);

            MetaCatUtil.debugMessage("The conection time it has: "

                                                +db.getConnectionTime(), 5);

            //set check out time

            db.setCheckOutTime(System.currentTimeMillis());

            //check it out

            return db;

          }//if

          else//The DBConnection has some problem

          {

            //close this DBConnection

            db.close();

            //remove it form connection pool

            connectionPool.remove(i);

            //insert a new DBConnection to same palace

            db = new DBConnection();

            connectionPool.insertElementAt(db, i);

          }//else

        }//if

      }//for

    //if couldn't get a connection, we should increase DBConnection pool

    //if the connection pool size is less than maximum connection number

    int poolSize = connectionPool.size(); 

    if ( poolSize < MAXIMUMCONNECTIONNUMBER )

    {

       if ((poolSize+INCREASECONNECTIONNUMBER) < MAXIMUMCONNECTIONNUMBER)

       { 

         //if we can create INCREASECONNECTIONNUMBER of new DBConnection

         //add to connection pool

         for ( int i=0; i<INCREASECONNECTIONNUMBER; i++)

         {

           DBConnection dbConn = new DBConnection();

           connectionPool.add(dbConn);

         }//for

       }//if

       else

       {

         //There is no enough room to increase INCREASECONNECTIONNUMBER 

         //we create new DBCoonection to Maximum connection number

         for (int i= poolSize+1; i<= MAXIMUMCONNECTIONNUMBER; i++)

         {

           DBConnection dbConn = new DBConnection();

           connectionPool.add(dbConn);

         }//for

       }//else

    }//if

    else

    {

      throw new SQLException("The maximum of " +MAXIMUMCONNECTIONNUMBER + 

                            " open db connections is reached." +

                            " New db connection to MetaCat" +

                            " cannot be established.");

    }//else

    //recursive to get new connection    

    return getDBConnection();

  }//getDBConnection

      //count connection time

      //set check out time to 0

      dbConn.setCheckOutTime(0);

    if (DBCONNECTIONRECYCLETHREAD.equals("on"))

    {

      runner.interrupt();

    }

          //if a DBConnection time is greater than 30000 milliseconds 

          //print it out

          if ((System.currentTimeMillis()-dbConn.getCheckOutTime())>=30000)

          {

            MetaCatUtil.debugMessage("This DBConnection is checked out for"

              +(System.currentTimeMillis()-dbConn.getCheckOutTime())/1000 , 1);

            MetaCatUtil.debugMessage(dbConn.getTag(), 1);

            MetaCatUtil.debugMessage(dbConn.getCheckOutMethodName(), 1);

          }

          //check the validation of free connection in the pool

                                    +" : "+ dbConn.getWarningMessage(), 1);

      //Thread sleep 

        Thread.sleep(CYCLETIMEOFDBCONNECTION);