zoukankan      html  css  js  c++  java
  • 连接池c3p0 ,Proxool ,Druid ,Tomcat Jdbc Pool对比测试

    这次所要做的测试是比较几种我们常用的数据库连接池的性能,他们分别是:c3p0 ,Proxool ,Druid ,Tomcat Jdbc Pool这四种,测试将采用统一的参数配置力求比较“公平”的体现统一水平下几种连接池的不同。

            1.创建类TestDAO,封装统一的查询方法 :

    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    public class TestDAO {
    
        private final static String sql = "SELECT * FROM USER u WHERE u.USR_ID=9999";
    
        public void query(Connection conn) {
            try {
                Statement st = conn.createStatement();
                ResultSet result = st.executeQuery(sql);
                result.close();
                st.close();
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

            2.创建测试类TestMain,其中包含:统一参数配置属性、获取各种连接池数据源方法、各种数据源调用方法等,代码较长但不难理解:

    import java.beans.PropertyVetoException;
    import java.io.IOException;
    import java.sql.SQLException;
    import org.apache.tomcat.jdbc.pool.DataSource;
    import org.logicalcobwebs.proxool.ProxoolDataSource;
    import com.alibaba.druid.pool.DruidDataSource;
    import com.mchange.v2.c3p0.ComboPooledDataSource;
    
    public class TestMain {
    
        // 数据库驱动名称
        static String driver = "com.mysql.jdbc.Driver";
    
        // 数据库连接地址
        static String jdbcUrl = "jdbc:mysql://192.168.0.1:3306/test";
    
        // 数据库用户名
        static String user = "dba";
    
        // 数据库密码
        static String passwd = "123456";
    
        // 连接池初始化大小
        static int initialSize = 5;
    
        // 连接池最小空闲
        static int minPoolSize = 10;
    
        // 连接池最大连接数量
        static int maxPoolSize = 50;
    
        // 最小逐出时间,100秒
        static int maxIdleTime = 100000;
    
        // 连接失败重试次数
        static int retryAttempts = 10;
    
        // 当连接池连接耗尽时获取连接数
        static int acquireIncrement = 5;
    
        // c3p0数据源
        static ComboPooledDataSource c3p0DataSource = getC3p0DataSource();
    
        // Druid数据源
        static DruidDataSource druidDataSource = getDruidDataSource();
    
        // Proxool数据源
        static ProxoolDataSource proxoolDataSource = getProxoolDataSource();
    
        // Tomcat Jdbc Pool数据源
        static DataSource tomcatDataSource = getTomcatDataSource();
    
        /**
         * 测试方式: 每种数据源配置信息尽量相同,以求结果更加准确
         * 每种数据源做10次、100次、500次、1000次、2000次、4000次、8000次查询操作 每种查询重复100次,查看100次执行时间的波动图
         * @param args
         * @throws IOException
         * @throws SQLException
         */
        public static void main(String[] args) throws IOException, SQLException {
    
            TestDAO testDAO = new TestDAO();
            // 查询次数
            int count = 10;
            System.out.println("查询次数为:" + count);
            System.out.println();
            System.out.println("==========================c3p0 测试开始==========================");
            // 测试c3p0
            for (int i = 0; i < 100; i++) {
                queryC3p0(testDAO, c3p0DataSource, count);
            }
            System.out.println("==========================c3p0 测试结束==========================");
            System.out.println();
            System.out.println("==========================Proxool 测试开始==========================");
            // 测试Proxool
            for (int i = 0; i < 100; i++) {
                queryProxxool(testDAO, proxoolDataSource, count);
            }
            System.out.println("==========================Proxool 测试结束==========================");
            System.out.println();
            System.out.println("==========================Druid 测试开始==========================");
            // 测试Druid
            for (int i = 0; i < 100; i++) {
                queryDruid(testDAO, druidDataSource, count);
            }
            System.out.println("==========================Druid 测试结束==========================");
            System.out.println();
            System.out.println("==========================Tomcat Jdbc Pool 测试开始==========================");
            // 测试Tomcat Jdbc Pool
            for (int i = 0; i < 100; i++) {
                queryTomcatJDBC(testDAO, tomcatDataSource, count);
            }
            System.out.println("==========================Tomcat Jdbc Pool 测试结束==========================");
        }
    
        /**
         * c3p0测试
         * @param testDAO
         * @param ds
         * @param count
         * @throws SQLException
         */
        public static void queryC3p0(TestDAO testDAO, ComboPooledDataSource ds, int count) throws SQLException {
            // 查询10次以初始化连接池
            for (int i = 0; i < 10; i++) {
                testDAO.query(ds.getConnection());
            }
            // 开始时间
            long startMillis = System.currentTimeMillis();
            // 循环查询
            for (int i = 0; i < count; i++) {
                testDAO.query(ds.getConnection());
            }
            // 结束时间
            long endMillis = System.currentTimeMillis();
            // 输出结束时间
            System.out.println(endMillis - startMillis);
        }
    
        /**
         * Proxxool测试
         * @param testDAO
         * @param ds
         * @param count
         * @throws SQLException
         */
        public static void queryProxxool(TestDAO testDAO, ProxoolDataSource ds, int count) throws SQLException {
            // 查询10次以初始化连接池
            for (int i = 0; i < 10; i++) {
                testDAO.query(ds.getConnection());
            }
            // 开始时间
            long startMillis = System.currentTimeMillis();
            // 循环查询
            for (int i = 0; i < count; i++) {
                testDAO.query(ds.getConnection());
            }
            // 结束时间
            long endMillis = System.currentTimeMillis();
            // 输出结束时间
            System.out.println(endMillis - startMillis);
        }
    
        /**
         * Druid测试
         * @param testDAO
         * @param ds
         * @param count
         * @throws SQLException
         */
        public static void queryDruid(TestDAO testDAO, DruidDataSource ds, int count) throws SQLException {
            // 查询10次以初始化连接池
            for (int i = 0; i < 10; i++) {
                testDAO.query(ds.getConnection());
            }
            // 开始时间
            long startMillis = System.currentTimeMillis();
            // 循环查询
            for (int i = 0; i < count; i++) {
                testDAO.query(ds.getConnection());
            }
            // 结束时间
            long endMillis = System.currentTimeMillis();
            // 输出结束时间
            System.out.println(endMillis - startMillis);
        }
    
        /**
         * Tomcat Jdbc Pool测试
         * @param testDAO
         * @param ds
         * @param count
         * @throws SQLException
         */
        public static void queryTomcatJDBC(TestDAO testDAO, DataSource ds, int count) throws SQLException {
            // 查询10次以初始化连接池
            for (int i = 0; i < 10; i++) {
                testDAO.query(ds.getConnection());
            }
            // 开始时间
            long startMillis = System.currentTimeMillis();
            // 循环查询
            for (int i = 0; i < count; i++) {
                testDAO.query(ds.getConnection());
            }
            // 结束时间
            long endMillis = System.currentTimeMillis();
            // 输出结束时间
            System.out.println(endMillis - startMillis);
        }
    
        /**
         * 获取c3p0数据源
         * @throws PropertyVetoException
         */
        public static ComboPooledDataSource getC3p0DataSource() {
            // 设置参数
            ComboPooledDataSource cpds = new ComboPooledDataSource();
            try {
                cpds.setDriverClass(driver);
            } catch (PropertyVetoException e) {
                e.printStackTrace();
            }
            cpds.setJdbcUrl(jdbcUrl);
            cpds.setUser(user);
            cpds.setPassword(passwd);
            cpds.setInitialPoolSize(initialSize);
            cpds.setMinPoolSize(minPoolSize);
            cpds.setMaxPoolSize(maxPoolSize);
            cpds.setMaxIdleTime(maxIdleTime);
            cpds.setAcquireRetryAttempts(retryAttempts);
            cpds.setAcquireIncrement(acquireIncrement);
            cpds.setTestConnectionOnCheckin(false);
            cpds.setTestConnectionOnCheckout(false);
            return cpds;
        }
    
        /**
         * 获取Druid数据源
         * @return
         */
        public static DruidDataSource getDruidDataSource() {
            DruidDataSource dds = new DruidDataSource();
            dds.setUsername(user);
            dds.setUrl(jdbcUrl);
            dds.setPassword(passwd);
            dds.setDriverClassName(driver);
            dds.setInitialSize(initialSize);
            dds.setMaxActive(maxPoolSize);
            dds.setMaxWait(maxIdleTime);
            dds.setTestWhileIdle(false);
            dds.setTestOnReturn(false);
            dds.setTestOnBorrow(false);
            return dds;
        }
    
        /**
         * 获取Proxool数据源
         * @return
         */
        public static ProxoolDataSource getProxoolDataSource() {
            ProxoolDataSource pds = new ProxoolDataSource();
            pds.setAlias("mysql");
            pds.setUser(user);
            pds.setPassword(passwd);
            pds.setDriverUrl(jdbcUrl);
            pds.setDriver(driver);
            pds.setMaximumActiveTime(maxIdleTime);
            pds.setMaximumConnectionCount(maxPoolSize);
            pds.setMinimumConnectionCount(initialSize);
            pds.setPrototypeCount(minPoolSize);
            pds.setTestBeforeUse(false);
            pds.setTestAfterUse(false);
            return pds;
        }
    
        /**
         * 获取Apache tomcat jdbc pool数据源
         * @return
         */
        public static DataSource getTomcatDataSource() {
            DataSource ds = new DataSource();
            ds.setUrl(jdbcUrl);
            ds.setUsername(user);
            ds.setPassword(passwd);
            ds.setDriverClassName(driver);
            ds.setInitialSize(initialSize);
            ds.setMaxIdle(minPoolSize);
            ds.setMaxActive(maxPoolSize);
            ds.setTestWhileIdle(false);
            ds.setTestOnBorrow(false);
            ds.setTestOnConnect(false);
            ds.setTestOnReturn(false);
            return ds;
        }
    }

            3.将测试结果粘贴到excel中,生成图表进行对比,可以很直观的看出几种数据源的性能差异,本文底部有此次测试的结果文档。

            以下就是此次测试结果(本结果只供参考,更具体更准确的测试可以自行进行):

            1.测试次数为10次时:

            平均用时(单位:毫秒):

    c3p0 36.29
    Proxool 41.46
    Druid 32.83
    Tomcat Jdbc Pool 32.91

            评论:

            但从时间来看Druid >Tomcat Jdbc Pool >c3p0 >Proxool,在测试的最后Proxool出现了一次异常导致前面较好的波动曲线大幅震荡。 
            只做简单的10次查询数据库时从图中观察到稳定性较好的是c3p0 ,他没有出现较高峰值的情况,虽然平均用时并不是最短的。

            2.测试次数为100次时:


      

            平均用时(单位:毫秒):

    c3p0 342.73
    Proxool 344.65
    Druid 317.15
    Tomcat Jdbc Pool 293.23

            评论:

            这里单单从图表中就会很清晰的发现Tomcat Jdbc Pool的性能稳定且耗时最短。Druid与Proxool依旧出现不稳定的情况。

            3.测试次数为500次时:

            平均用时(单位:毫秒):

    c3p0 1420.67
    Proxool 1551.69
    Druid 1519.61
    Tomcat Jdbc Pool 1491.88

            评论:

            此次测试结果比较意外Tomcat Jdbc Pool出现了一次大幅度的波动,Proxool依旧不稳定。在500次查询过程中c3p0表现出来非常好的稳定性及性能。

            4.测试次数为1000次时:
     

            平均用时(单位:毫秒):

    c3p0  3530.26
    Proxool  3140.97
    Druid  3090.06
    Tomcat Jdbc Pool  3164.57
  • 相关阅读:
    day20:正则表达式
    day19:os模块&shutil模块&tarfile模块
    zynq之TF卡写入常见问题
    verilog之random
    quartus之ram的IP测试
    verilog之readmemb
    verilog之monitor
    verilog之display
    源自opencore的fifo的IP核解析
    veriog之四位全加器
  • 原文地址:https://www.cnblogs.com/barrywxx/p/6343303.html
Copyright © 2011-2022 走看看