连接池c3p0 ,Proxool ,Druid ,Tomcat Jdbc Pool对比测试

时间 2013-08-05 15:05:57  ITeye-博客

原文  http://286.iteye.com/blog/1920417

        这次所要做的测试是比较几种我们常用的数据库连接池的性能，他们分别是：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

不好意思，下班了 明天继续