/src/edu/ucsb/nceas/metacat/DBConnectionPool.java - Diff - Metacat - Ecoinformatics Redmine

« Previous | Next »

Revision 1217

Added by Jing Tao almost 22 years ago

Merge DBConnection branch to head.

       final static long CYCLETIMEOFDBCONNECTION =
                    Long.parseLong(MetaCatUtil.getOption("cycleTimeOfDBConnection"));
       //the number for trying to check out a connection in the pool in
       //getDBConnection method
       final static int LIMIT = 2;
       final static int FREE = 0; //status of a connection
       final static int BUSY = 1; //statis of a connection
-...
                                                     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++)
         int random = 0; //random number
         int index = 0; //index
         int size = 0; //size of connection pool
         MetaCatUtil.debugMessage("Try to checking out connection...", 45);
         size = connectionPool.size();
         MetaCatUtil.debugMessage("size of connection pool: "+size, 45);
          //try every DBConnection in the pool
         //every DBConnection will be try LIMITE times
         for (int j=0 ; j<LIMIT; j++)
+        {
            //create a random number as the started index for connection pool
           //So that the connection ofindex of 0 wouldn't be a the heaviest user
           random = (new Double (Math.random()*100)).intValue();
           for (int i=0; i<size; i++)
+          {
             db = (DBConnection) connectionPool.elementAt(i);
             index =(i+random)%size;
             db = (DBConnection) connectionPool.elementAt(index);
             MetaCatUtil.debugMessage("Index: "+index, 45);
             MetaCatUtil.debugMessage("Tag: "+db.getTag(), 45);
             MetaCatUtil.debugMessage("Status: "+db.getStatus(), 45);
             //check if the connection is free
             if (db.getStatus()==FREE)
+            {
-...
                 db.setCheckOutMethodName(methodName);
                 //debug message
                 MetaCatUtil.debugMessage("The connection is checked out: "
                                            +db.getTag(), 20);
                 MetaCatUtil.debugMessage("The age is "+db.getAge(), 25);
                 MetaCatUtil.debugMessage("The usage is "+db.getUsageCount(), 25);
                                            +db.getTag(), 35);
                 MetaCatUtil.debugMessage("The method for checking is: "
                                                   +db.getCheckOutMethodName(), 35);
                 MetaCatUtil.debugMessage("The age is "+db.getAge(), 40);
                 MetaCatUtil.debugMessage("The usage is "+db.getUsageCount(), 40);
                 MetaCatUtil.debugMessage("The conection time it has: "
                                                     +db.getConnectionTime(), 25);
                                                     +db.getConnectionTime(), 40);
                 //set check out time
                 db.setCheckOutTime(System.currentTimeMillis());
                 //check it out
-...
                 //close this DBConnection
                 db.close();
                 //remove it form connection pool
                 connectionPool.remove(i);
                 connectionPool.remove(index);
                 //insert a new DBConnection to same palace
                 db = new DBConnection();
                 connectionPool.insertElementAt(db, i);
                 connectionPool.insertElementAt(db, index);
               }//else
             }//if
           }//for
         }//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 ( size < MAXIMUMCONNECTIONNUMBER )
+        {
            if ((poolSize+INCREASECONNECTIONNUMBER) < MAXIMUMCONNECTIONNUMBER)
            if ((size+INCREASECONNECTIONNUMBER) < MAXIMUMCONNECTIONNUMBER)
+           {
              //if we can create INCREASECONNECTIONNUMBER of new DBConnection
              //add to connection pool
-...
+           {
              //There is no enough room to increase INCREASECONNECTIONNUMBER
              //we create new DBCoonection to Maximum connection number
              for (int i= poolSize+1; i<= MAXIMUMCONNECTIONNUMBER; i++)
              for (int i= size+1; i<= MAXIMUMCONNECTIONNUMBER; i++)
+             {
                DBConnection dbConn = new DBConnection();
                connectionPool.add(dbConn);
-...
         }//if
         else
+        {
           throw new SQLException("The maximum of " +MAXIMUMCONNECTIONNUMBER +
           /*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
       /**
        * 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
        */
       public static synchronized DBConnection getDBConnection() 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 checkout serial number
                 db.increaseCheckOutSerialNumber(1);
                 //increase one usageCount
                 db.increaseUsageCount(1);
                 //debug message
                 MetaCatUtil.debugMessage("The connection is checked out: "
                                            +db.getTag(), 25);
                 MetaCatUtil.debugMessage("The age is "+db.getAge(), 25);
                 MetaCatUtil.debugMessage("The usage is "+db.getUsageCount(), 25);
                 MetaCatUtil.debugMessage("The conection time it has: "
                                                     +db.getConnectionTime(), 25);
                 //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 +
                                 " cannot be established.");*/
            MetaCatUtil.debugMessage("The maximum of " +MAXIMUMCONNECTIONNUMBER +
                                 " open db connections is reached." +
                                 " New db connection to MetaCat" +
                                 " cannot be established.");
                                 " cannot be established.", 1);
            return null;
            //if couldn't get a connection, sleep 20 seconds and try again.
            /*try
+           {
              System.out.println("sleep");
              Thread.sleep(2000);
+           }
            catch (Exception e)
+           {
            }*/
         }//else
         //recursive to get new connection
         return getDBConnection();
         return getDBConnection(methodName);
       }//getDBConnection
       /**
        * Method to check if a db connection works fine or not
        * Check points include:
-...
        */
       private static boolean validateDBConnection (DBConnection dbConn)
+      {
         Connection conn = null;
         //Check if the DBConnection usageCount if it is too many
         if (dbConn.getUsageCount() >= MAXIMUMUSAGENUMBER )
+        {
-...
+        }
         //Try to run a simple query
         conn = dbConn.getConnections();
         try
+        {
           long startTime=System.currentTimeMillis();
           conn.getMetaData();
           DatabaseMetaData metaData = dbConn.getMetaData();
           long stopTime=System.currentTimeMillis();
           //increase one usagecount
           dbConn.increaseUsageCount(1);
-...
+        {
           MetaCatUtil.debugMessage("Couldn't find a DBConnection in the pool"
                                       +" which have same tag to the returned"
                                       +" DBConnetion object");
                                       +" DBConnetion object", 30);
           return;
         }//if
-...
             //set check out time to 0
             dbConn.setCheckOutTime(0);
             MetaCatUtil.debugMessage("Connection: "+dbConn.getTag()+" checked in.",
 );
 );
              MetaCatUtil.debugMessage("Connection: "+dbConn.getTag()+"'s status: "
                                                         +dbConn.getStatus(), 35);
           }//if
           else
+          {
             MetaCatUtil.debugMessage("This DBConnection couldn't return", 30);
           }//else
         }//else
-...
+      {
         int index = -1;
         String info = null;
         //if conn is null return -1 too
         if (conn==null)
+        {
           return -1;
+        }
         //get tag of this returned DBConnection
         info = conn.getTag();
         //if the tag is null or empty, -1 will be returned
-...
         }//while
       }//run
       /**
        * Method to get the number of free DBConnection in DBConnection pool
        */
       public int getFreeDBConnectionNumber()
+      {
         int numberOfFreeDBConnetion = 0; //return number
         DBConnection db = null; //single DBconnection
         int poolSize = 0; //size of connection pool
         //get the size of DBConnection pool
         poolSize = connectionPool.size();
         //Check every DBConnection in the pool
         for ( int i=0; i<poolSize; i++)
+        {
           db = (DBConnection) connectionPool.elementAt(i);
           //check the status of db. If it is free, count it
           if (db.getStatus() == FREE)
+          {
             numberOfFreeDBConnetion++;
           }//if
         }//for
         //return the count result
         return numberOfFreeDBConnetion;
       }//getFreeDBConnectionNumber
        /**
        * Method to print out the method name which have busy DBconnection
        */
       public void printMethodNameHavingBusyDBConnection()
+      {
         DBConnection db = null; //single DBconnection
         int poolSize = 0; //size of connection pool
         //get the size of DBConnection pool
         poolSize = connectionPool.size();
         //Check every DBConnection in the pool
         for ( int i=0; i<poolSize; i++)
+        {
           db = (DBConnection) connectionPool.elementAt(i);
           //check the status of db. If it is free, count it
           if (db.getStatus() == BUSY)
+          {
             MetaCatUtil.debugMessage("This method having a busy DBConnection: "
                                         +db.getCheckOutMethodName(), 30);
             MetaCatUtil.debugMessage("The busy DBConnection tag is: "
                                         +db.getTag(), 30);
           }//if
         }//for
       }//printMethodNameHavingBusyDBConnection
     }//DBConnectionPool

Also available in: Unified diff

Project

General

Profile

Metacat

Revision 1217

Added by Jing Tao almost 22 years ago