自分で書いたJDBC接続プールは、ざらざらしています


1と2は接続プール、3と4はデータをテストまたは挿入するための駆動である.
プログラム実行後のコマンドの例:
new 100は100個の接続を申請する
drop 100は100を池に戻します
Query 100000SQL文100000回、例えばデータの挿入
quit終了

  
  
  
  
  1. //1.connPool.java  
  2.  
  3. package Data;  
  4.  
  5. import java.util.ArrayList;  
  6.  
  7. import java.util.List;  
  8.  
  9. import java.sql.*;  
  10.  
  11.  
  12.  
  13.  
  14. public class connPool {  
  15.  
  16.       
  17.  
  18.     private List<Connection> pool; //it contains connections  
  19.  
  20.       
  21.  
  22.     public connPool()  
  23.  
  24.     {  
  25.  
  26.         pool=new ArrayList<Connection>();  
  27.  
  28.     }  
  29.  
  30.       
  31.  
  32.     synchronized public boolean putConn(Connection conn) throws SQLException //put connection back  
  33.  
  34.     {  
  35.  
  36.         if(conn==null||conn.isClosed()) //check,throws SQLException  
  37.  
  38.             return false;  
  39.  
  40.         else 
  41.  
  42.         {  
  43.  
  44.             return pool.add(conn);  
  45.  
  46.         }  
  47.  
  48.     }  
  49.  
  50.       
  51.  
  52.     synchronized public Connection getConn() //fetch a connection  
  53.  
  54.     {  
  55.  
  56.         if(pool.size()<=0)  
  57.  
  58.             return null;  
  59.  
  60.         else 
  61.  
  62.         {  
  63.  
  64.             return pool.remove(0);  
  65.  
  66.         }  
  67.  
  68.     }  
  69.  
  70.       
  71.  
  72.     synchronized public boolean reduceOne() //reduce the connections storage  
  73.  
  74.     {  
  75.  
  76.         if(pool.size()<=0)  
  77.  
  78.             return false;  
  79.  
  80.         else 
  81.  
  82.         {  
  83.  
  84.             try {  
  85.  
  86.                 pool.remove(0).close();  
  87.  
  88.             } catch (SQLException e) {  
  89.  
  90.                 e.printStackTrace();  
  91.  
  92.                 return false;  
  93.  
  94.             }  
  95.  
  96.             return true;  
  97.  
  98.         }  
  99.  
  100.     }  
  101.  
  102.       
  103.  
  104.     public int getNum()  //how many connections is there  
  105.  
  106.     {  
  107.  
  108.         return pool.size();  
  109.  
  110.     }  
  111.  
  112.       
  113.  
  114. }  
  115.  
  116. //2.DBDriver.java  
  117. package Data;  
  118.  
  119.  
  120. import java.sql.*;  
  121.  
  122.  
  123. public class DBDriver {  
  124.  
  125.  
  126.     static final int NumWhenStart = 10// how many conns should be created whenstart  
  127.  
  128.  
  129.     static final int NumWhenIncrease = 5;// how many conns should add when thereis few conns  
  130.  
  131.  
  132.     static final int NumJudgeOver = 20// num to judge if the pool has too many conns;  
  133.  
  134.  
  135.     static final int NumReduceTo = 10// num should the pool reduce to  
  136.       
  137.     static final int NumLowCase = 2//num few conns  
  138.  
  139.  
  140.     private String host; //host name  
  141.     private String user; //database user  
  142.     private String pwd; //password  
  143.     private String database; //database name  
  144.     private String driverName; //JDBC Driver  
  145.         private String dbURL; //database connection url  
  146.     private connPool pool; //connection pool  
  147.          
  148.     private static DBDriver instance = null//singleton instance  
  149.  
  150.  
  151.     public static DBDriver getInstance() {  //singleton  
  152.         if (instance == null) {  
  153.             synchronized (DBDriver.class) {  
  154.                 if (instance == null) {  
  155.                     try {  
  156.                         instance = new DBDriver();  
  157.                     } catch (Exception e) {  
  158.                         e.printStackTrace();  
  159.                         return null;  
  160.                     }  
  161.                 }  
  162.             }  
  163.         }  
  164.         return instance;  
  165.     }  
  166.  
  167.  
  168.     private DBDriver() throws Exception { //constructor  
  169.         pool = new connPool();  
  170.         host = "localhost";  
  171.         user = "sa";  
  172.         pwd = "put yours pwd here";  
  173.         database = "innov";  
  174.         driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver";  
  175.         dbURL = "jdbc:sqlserver://" + host + ":1433; DatabaseName=" 
  176.                 + database;  
  177.         Class.forName(driverName);  
  178.         for (int i = 0; i < NumWhenStart; i++) {  
  179.             Connection conn = DriverManager.getConnection(dbURL, user, pwd);  
  180.             pool.putConn(conn);  
  181.         }  
  182.     }  
  183.  
  184.  
  185.     public Connection getConn() { //get a connection  
  186.         Connection conn = null;  
  187.         if (pool.getNum() <= NumLowCase) {  
  188.             try {  
  189.                 Class.forName(driverName);  
  190.                 for (int i = 0; i < NumWhenIncrease; i++) {  
  191.                     conn = DriverManager.getConnection(dbURL, user, pwd);  
  192.                     pool.putConn(conn);  
  193.                 }  
  194.             } catch (Exception e) {  
  195.                 e.printStackTrace();  
  196.             }  
  197.         }  
  198.         return pool.getConn();  
  199.     }  
  200.  
  201.  
  202.     public boolean close(Connection conn) {  //put connections back  
  203.         boolean bool = false;  
  204.         try {  
  205.             bool = pool.putConn(conn);  
  206.         } catch (SQLException e) {  
  207.             e.printStackTrace();  
  208.         }  
  209.         if (pool.getNum() > NumJudgeOver) {  
  210.             while (pool.getNum() > NumReduceTo)  
  211.                 pool.reduceOne();  
  212.         }  
  213.         return bool;  
  214.     }  
  215.  
  216.  
  217.     public int getNum() { //return pool's connection number  
  218.         return pool.getNum();  
  219.     }  
  220. }  
  221. /*************************** **********************************/ 
  222. /*************************** ***********************/ 
  223. //3.SqlThread.java          //use multiple thread  
  224. import java.sql.*;  
  225. public class SqlThread extends Thread  
  226. {  
  227.     Connection conn;  
  228.     String sql;  
  229.     int times;  
  230.     public SqlThread(String name,Connection conn,String sql,int times)  
  231.     {  
  232.         super(name);  
  233.         this.times=times;  
  234.         this.sql=sql;  
  235.         this.conn=conn;  
  236.     }  
  237.  
  238.  
  239.     @Override 
  240.     public void run()  
  241.     {  
  242.         try 
  243.         {  
  244.             Statement stmt=conn.createStatement();  
  245.             for(int i=0;i<times;i++)  
  246.             {  
  247.                 stmt.execute(sql);  
  248.                 System.out.print("Thread "+this.getName()+" Reporting:"+(i+1)+" querys done.
    "
    );  
  249.                 sleep(3);  
  250.             }  
  251.         }catch(Exception e)  
  252.         {  
  253.             e.printStackTrace();  
  254.         }  
  255.         System.out.print("Thread "+this.getName()+" quit."+times+" querys done.
    "
    );  
  256.     }  
  257. }  
  258.  
  259.  
  260. //4.test.java  
  261.  
  262.  
  263. import java.sql.*;  
  264. import java.util.*;  
  265. import Data.DBDriver;  
  266.  
  267.  
  268. public class test {  
  269.  
  270.  
  271.     /**  
  272.      * @param args  
  273.      */ 
  274.     public static void main(String[] args) {  
  275.         System.out.print("program start
    "
    );  
  276.         DBDriver dbd = DBDriver.getInstance();  
  277.         List<Connection> connList = new ArrayList<Connection>();  
  278.         for(int i=0;i<3;i++)  
  279.         {  
  280.             connList.add(dbd.getConn());  
  281.         }  
  282.         System.out.print("using " + connList.size() + " conns,while " 
  283.                 + dbd.getNum() + " in pool
    "
    );  
  284.         Scanner jin = new Scanner(System.in);  
  285.         String cmd;  
  286.         int flag = 0;  
  287.         while (jin.hasNext()) {  
  288.             cmd = jin.next();  
  289.             if (flag == 0) {  
  290.                 if (cmd.equals("quit")) {  
  291.                     System.out.print("Bye Bye");  
  292.                     break;  
  293.                 } else if (cmd.equals("new")) {  
  294.                     flag = 1;  
  295.                 } else if (cmd.equals("drop")) {  
  296.                     flag = 2;  
  297.                 } else if (cmd.equals("query")) {  
  298.                     flag = 3;  
  299.                 } else {  
  300.                     System.out.print("Unknown command
    "
    );  
  301.                 }  
  302.             } else {  
  303.                 if (flag == 1) {  
  304.                     int num = Integer.parseInt(cmd);  
  305.                     for (int i = 0; i < num; i++) {  
  306.                         connList.add(dbd.getConn());  
  307.                     }  
  308.                     System.out.print("System:operation done!
    using "
     
  309.                             + connList.size() + " conns,while " + dbd.getNum()  
  310.                             + " in pool
    "
    );  
  311.                     flag = 0;  
  312.                 } else if (flag == 2) {  
  313.                     int num = Integer.parseInt(cmd);  
  314.                     int size = connList.size();  
  315.                     for (int i = 0; i < ((num > size) ? size : num); i++) {  
  316.                         if (dbd.close(connList.get(0))) {  
  317.                             connList.remove(0);  
  318.                         } else {  
  319.                             System.out.print("fail when drop " + i + "
    "
    );  
  320.                         }  
  321.                     }  
  322.                     System.out.print("System:operation done!
    using "
     
  323.                             + connList.size() + " conns,while " + dbd.getNum()  
  324.                             + " in pool
    "
    );  
  325.                     flag = 0;  
  326.                 } else if (flag == 3) {  
  327.                     int num = Integer.parseInt(cmd);  
  328.                     String sql = jin.nextLine();  
  329.                     for (int i = 0; i < 3; i++) {  
  330.                         try {  
  331.                             Thread t=new SqlThread(String.valueOf(i),connList.get(i),sql,num/3+((i<2)?0:(num%3)));  
  332.                             t.start();  
  333.                         } catch (Exception e) {  
  334.                             e.printStackTrace();  
  335.                         }  
  336.                     }  
  337.                     flag = 0;  
  338.                 } else if (flag == 4) {  
  339.                     int num = Integer.parseInt(cmd);  
  340.                     int size = connList.size();  
  341.                     String sql = jin.nextLine();  
  342.                     Statement stmt = null;  
  343.                     for (int i = 0; i < ((num > size) ? size : num); i++) {  
  344.                         try {  
  345.                             Thread t=new SqlThread(String.valueOf(i),connList.get(i),sql,1);  
  346.                         } catch (Exception e) {  
  347.                             e.printStackTrace();  
  348.                         }  
  349.                     }  
  350.                     System.out.print("System:operation done!
    using "
     
  351.                             + connList.size() + " conns,while " + dbd.getNum()  
  352.                             + " in pool
    "
    );  
  353.                     flag = 0;  
  354.                 }  
  355.             }  
  356.         }  
  357.     }  
  358. }