ccache5.java

Java示例100

/**
   Oracle JDBC supports a JDBC connection cache time-out scheme. The intent is
   to unconditionally reclaim connections. This guarantees the
   reclamation of connection resources no matter middle tier or application
   explicitly close the connection or not.

   There are 3 connection cache time-out:
         TimeToLive timeout
         Inactivity timeout
         FixedWait  timeout

   This file is a sample to illustrate Inactivity timeout.

   Inactivity time-out is a period of inactivity for a given connection. The
   connection will be closed after the specified period of inactivity.

   The default value is -1, which means timeout thread won't reclaim the
   corresponding resources (the physical connection will remain if middle tier
   or application does not explicitly call close() even its logical connectin
   is closed long time ago

   Please refer to CCache4.java, CCache6.java, and CCache7.java for other
   timeout features.
 **/ 


import java.sql.*;
import javax.sql.*;
import oracle.jdbc.*;
import oracle.jdbc.pool.*;

class CCache5 extends Thread
{
    OracleConnectionCacheImpl ods = null;

    public static void main (String args[]) throws SQLException
    {
         CCache5 cc5 = new CCache5 ();
         cc5.start ();
    }

    public void run ()
    {
         dynamicInactive ();
         fixedReturnNullInactive ();
         fixedwaitInactive ();
         defaultInactive ();
    } // end of run () 


    private void setods()
    {
         // make an oracle connection cache instance
         try
         {
             ods = new OracleConnectionCacheImpl();
         } catch (SQLException e)
         {
             e.printStackTrace();
         }

         String url = "jdbc:oracle:oci:@"; // thin driver can be used as well
         try
         {
              String url1 = System.getProperty("JDBC_URL");
              if (url1 != null)
                    url = url1;
         } catch (Exception e) { }

         ods.setURL (url);
         ods.setUser ("hr");
         ods.setPassword ("hr");

         try
         {
             ods.setMaxLimit (3);
         } catch (SQLException e)
         {
             e.printStackTrace();
         }
    } // end of private void setods ()

         
    //
    // combine Inactivity Timeout with DYNAMIC_SCHEME.
    // Maxlimit set to 3 but 5 connections can be obtained at the
    // same time. 
    //
    // 3 inactive (closed) connections will be reclaimed
    // 
    private void dynamicInactive ()
    {
        setods ();
        try
        {
             ods.setCacheScheme (OracleConnectionCacheImpl.DYNAMIC_SCHEME);

             // Note, threadWakeUpInterval should be less than Inactivity
             // Timeout
             ods.setThreadWakeUpInterval (1);
             ods.setCacheInactivityTimeout (5);
        } catch (SQLException e)
        {
             e.printStackTrace();
        }

        System.out.println("\nCombine Inactivity Timeout with DYNAMIC_SCHEME");
        System.out.println("Max Limit size for cache is 3,\n" +
                           "but 5 connections can be obtained\n");

        Connection[] conn = new Connection[5];
        for ( int i = 0; i < 5; ++i )
        {
            try
            {
                conn[i] = ods.getConnection();
            } catch (SQLException e)
            {
                System.out.println("Failed: ");
                e.printStackTrace();
            }
            if ( conn[i] != null )
                System.out.println("Succeed at connection " + (i+1));
            else
                System.out.println("Failed at connection " + (i+1));
        }
        System.out.println("After making 5 connections");
        System.out.println("Active size : " + ods.getActiveSize()); // expect 5
        System.out.println("Cache Size : " + ods.getCacheSize());  // expect 5

        // Make 3 connections inactive by closing these 3 logical
        // connections and return them to cache
        try
        {
            conn[0].close();
            conn[1].close();
            conn[2].close();
        } catch (SQLException e)
        {
            e.printStackTrace();
        }

        // sleep for 10 seconds, so timeout thread can close the
        // physical connections in cache
        try
        {
            System.out.println("Sleeping for 10 seconds...");
            Thread.sleep (10000);
        }
        catch (java.lang.InterruptedException ie) {}

        System.out.println("When 3 logical connections become inactive for a " +
                           "period of time of connection cache Inactivity timeout");
        System.out.println("3 physical connections are closed by the timeout thread.");
        System.out.println("Active size : " + ods.getActiveSize()); // expect 2
        System.out.println("Cache Size : " + ods.getCacheSize());  // expect 2

        try
        {
            conn[3].close();
            conn[4].close();
            ods.close();
            ods = null;
        } catch (SQLException e)
        {
            e.printStackTrace();
        }
    } // end of private void dynamicInavtive ()


    //
    // combination with FIXED_RETURN_NULL_SCHEME
    // Maxlimit set to 3 but 5 connections are tried at the same time
    // with 3 success and 2 fail. 
    //
    private void fixedReturnNullInactive( )
    {
        setods ();
        try
        {
            ods.setCacheScheme (OracleConnectionCacheImpl.FIXED_RETURN_NULL_SCHEME);
            ods.setThreadWakeUpInterval (1); // timeout thread wake ups every 1 second
            ods.setCacheInactivityTimeout (5); // 5 seconds
        } catch (SQLException e)
        {
            e.printStackTrace();
        }

        System.out.println("\nCombine Inactivity Timeout and FIXED_RETURN_NULL_SCHEME");
        System.out.println("Max Limit size for cache is 3, but 5 connections are" +
                         " tried with 3 success and 2 fail");

        Connection[] conn = new Connection[5];
        for ( int i = 0; i < 5; ++i )
        {
            try
            {
                 // get a logical connection from the Cache.
                 conn[i] = ods.getConnection();
            } catch (SQLException e)
            {
                e.printStackTrace();
            }

            if ( conn[i] != null )
                System.out.println("Succeed at connection " + (i+1));
            else
                System.out.println("Expected Fail at connection " + (i+1));
        }
        System.out.println("After connection creation.");
        System.out.println("Active size : " + ods.getActiveSize()); // expect 3
        System.out.println("Cache Size : " + ods.getCacheSize());  // expect 3

        for (int i = 0; i < 5; ++i)
            if ( conn[i] != null )
                try
                {
                    conn[i].close();
                }
                catch (SQLException e)
                {
                    e.printStackTrace();
                }

        // sleep for 10 seconds, so timeout thread can close the active connections
        try
        {
            System.out.println("Sleeping for 10 seconds...");
            Thread.sleep (10000);
        }
        catch (java.lang.InterruptedException ie) {}

        System.out.println("After all the logical connections get closed,\n" +
                           "all the physical connections are closed without " +
                           "explicit calling to close.");
        System.out.println("Active size : " + ods.getActiveSize()); // expect 0
        System.out.println("Cache Size : " + ods.getCacheSize());  // expect 0
        try
        {
             ods.close();
        } catch (SQLException e)
        {
             e.printStackTrace ();
        }
    } // end of fixedReturnNullInactive ()



    //
    // Combine Inactivity time out with FIXED_WAIT_SCHEME
    // Maxlimit set to 3 but 5 connections are tried at the same time. 
    // with 3 succeed at ealier time, and 2 succeed at much later time.
    //
    // One connection will be made inactive (closed) when the
    // activeSize reaches Maxlimit 3.
    //
    private void fixedwaitInactive ()
    {
        setods ();
        try
        {
             ods.setCacheScheme (OracleConnectionCacheImpl.FIXED_WAIT_SCHEME);
             ods.setThreadWakeUpInterval (1); 
                              // Timeout Thread wakes up every second
             ods.setCacheInactivityTimeout (5);
        } catch (SQLException e)
        {
             e.printStackTrace();
        }

        System.out.println("\nCombine Inactivity Timeout and FIXED_WAIT_SCHEME");
        System.out.println("Max Limit size for cache is 3, " +
                           "but 5 connections are tried. \n3 success with ealier " +
                           "timestamp,\n2 success " +
                          "with about 10 seconds later timestamp");


        FixedWaitThread t1 = new FixedWaitThread (ods, 1);
        FixedWaitThread t2 = new FixedWaitThread (ods, 2);
        FixedWaitThread t3 = new FixedWaitThread (ods, 3);
        FixedWaitThread t4 = new FixedWaitThread (ods, 4);
        FixedWaitThread t5 = new FixedWaitThread (ods, 5);

        t1.start();
        t2.start();
        t3.start();
        t4.start();
        t5.start();

        // start everyone at the same time
        FixedWaitThread.setGreenLight();
        try
        {
            System.out.println("Sleeping for 10 seconds...");
            Thread.sleep (10000);
        }
        catch (java.lang.InterruptedException ie) {}

        int connkilled = 0;
        while ( (FixedWaitThread.getthreadnum() >= 4)
                && (connkilled <= 1) )
        {
            if ( FixedWaitThread.getconnum() >= 3 )
            {
                if ( t1.getconnected() )
                    t1.closeconnection();
                else if ( t2.getconnected() )
                    t2.closeconnection();
                else if ( t3.getconnected() )
                    t3.closeconnection();
                else if ( t4.getconnected() )
                    t4.closeconnection();
                else if ( t5.getconnected() )
                    t5.closeconnection();

                ++connkilled;
            }
        } // end of while loop
            

        t1.closeconnection();
        t2.closeconnection();
        t3.closeconnection();
        t4.closeconnection();
        t5.closeconnection();

        // wait for all threads to end
        try
        {
            t1.join ();
            t2.join ();
            t3.join ();
            t4.join ();
            t5.join ();
        } catch (Exception e)
        {
            e.printStackTrace();
        }

        try
        {
            Thread.sleep (10000);
        } catch (InterruptedException ie) {}
        System.out.println("Sleeping for 10 seconds, so timeout thread close " +
                           "all the physical connections.\n Cache Size: " +
                           ods.getCacheSize()); // expect 0

        try
        {
             ods.close();
             ods = null;
        } catch (SQLException e)
        {
             e.printStackTrace();
        }
    } // end of fixedwaitInactive ()



    //
    // At default setting (Inactivity time out takes -1), the physical connection
    // will remain even its corresponding logical connection got closed long time
    // ago
    // 
    private void defaultInactive ()
    {
        Connection conn = null;
        setods ();

        try
        {
             ods.setCacheScheme (OracleConnectionCacheImpl.DYNAMIC_SCHEME);
             ods.setThreadWakeUpInterval (1);
             conn = ods.getConnection(); 
        } catch (SQLException e)
        {
             e.printStackTrace();
        }

        System.out.println("\nUsing default Inactivity time out value -1");
        if ( conn != null )
                System.out.println("Succeed at connection");
        else
                System.out.println("Failed at connection");

        System.out.println("After making 1 connection");
        System.out.println("Active size : " + ods.getActiveSize()); // expect 1
        System.out.println("Cache Size : " + ods.getCacheSize());  // expect 1

        // Make the connection inactive by closing it
        try
        {
            conn.close();
            conn = null;
        } catch (SQLException e)
        {
            e.printStackTrace();
        }

        // sleep for 20 seconds, so timeout thread can close the
        // physical connections in cache
        try
        {
            System.out.println("Sleeping for 20 seconds...");
            Thread.sleep (20000);
        }
        catch (java.lang.InterruptedException ie) {}

        System.out.println("After closing the logical connection and waiting "
                           + "timeout thread taking place,\nphysical connection "
                           + "still there");
        System.out.println("Active size : " + ods.getActiveSize()); // expect 0
        System.out.println("Cache Size : " + ods.getCacheSize());  // expect 1

        try
        {
            ods.close();
            ods = null;
        } catch (SQLException e)
        {
            e.printStackTrace();
        }
    }
} // end of class CCache5