这次所要做的测试是比较几种我们常用的数据库连接池的性能，他们分别是：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，其中包含：统一参数配置属性、获取各种连接池数据源方法、各种数据源调用方法等，下面分别是各种数据源的测试Main方法，开始测试之前做100次查询操作以初始化连接池并起到稳定测试结果作用：
(1)c3p0测试代码：
import java.beans.PropertyVetoException;
import java.io.IOException;
import java.sql.SQLException;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class C3p0Test {
// 数据库驱动名称
final static String driver = "com.mysql.jdbc.Driver";
// 数据库连接地址
final static String jdbcUrl = "jdbc:mysql://192.168.0.1:3306/test";
// 数据库用户名
final static String user = "dba";
// 数据库密码
final static String passwd = "dba";
// 连接池初始化大小
final static int initialSize = 5;
// 连接池最小空闲
final static int minPoolSize = 10;
// 连接池最大连接数量
final static int maxPoolSize = 50;
// 最小逐出时间，100秒
final static int maxIdleTime = 100000;
// 连接失败重试次数
final static int retryAttempts = 10;
// 当连接池连接耗尽时获取连接数
final static int acquireIncrement = 5;
// c3p0数据源
final static ComboPooledDataSource c3p0DataSource = getC3p0DataSource();
// 查询次数
final static int count = 10;
/**
* 测试方式： 每种数据源配置信息尽量相同，以求结果更加准确
* 每种数据源做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();
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 测试结束==========================");
}
/**
* c3p0测试
* @param testDAO
* @param ds
* @param count
* @throws SQLException
*/
public static void queryC3p0(TestDAO testDAO, ComboPooledDataSource ds, int count) throws SQLException {
// 查询100次以初始化连接池
for (int i = 0; i < 100; 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;
}
}
(2)Proxool测试代码：
import java.io.IOException;
import java.sql.SQLException;
import org.logicalcobwebs.proxool.ProxoolDataSource;
public class ProxoolTest {
// 数据库驱动名称
final static String driver = "com.mysql.jdbc.Driver";
// 数据库连接地址
final static String jdbcUrl = "jdbc:mysql://192.168.0.1:3306/test";
// 数据库用户名
final static String user = "dba";
// 数据库密码
final static String passwd = "dba";
// 连接池初始化大小
final static int initialSize = 5;
// 连接池最小空闲
final static int minPoolSize = 10;
// 连接池最大连接数量
final static int maxPoolSize = 50;
// 最小逐出时间，100秒
final static int maxIdleTime = 100000;
// 连接失败重试次数
final static int retryAttempts = 10;
// 当连接池连接耗尽时获取连接数
final static int acquireIncrement = 5;
// Proxool数据源
final static ProxoolDataSource proxoolDataSource = getProxoolDataSource();
// 查询次数
final static int count = 10;
/**
* 测试方式： 每种数据源配置信息尽量相同，以求结果更加准确
* 每种数据源做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();
System.out.println("查询次数为：" + count);
System.out.println();
System.out.println("==========================Proxool 测试开始==========================");
// 测试Proxool
for (int i = 0; i < 100; i++) {
queryProxxool(testDAO, proxoolDataSource, count);
}
System.out.println("==========================Proxool 测试结束==========================");
}
/**
* Proxxool测试
* @param testDAO
* @param ds
* @param count
* @throws SQLException
*/
public static void queryProxxool(TestDAO testDAO, ProxoolDataSource ds, int count) throws SQLException {
// 查询100次以初始化连接池
for (int i = 0; i < 100; 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);
}
/**
* 获取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;
}
}
(3)Druid测试代码：
import java.io.IOException;
import java.sql.SQLException;
import com.alibaba.druid.pool.DruidDataSource;
public class DruidTest {
// 数据库驱动名称
final static String driver = "com.mysql.jdbc.Driver";
// 数据库连接地址
final static String jdbcUrl = "jdbc:mysql://192.168.0.1:3306/test";
// 数据库用户名
final static String user = "dba";
// 数据库密码
final static String passwd = "dba";
// 连接池初始化大小
final static int initialSize = 5;
// 连接池最小空闲
final static int minPoolSize = 10;
// 连接池最大连接数量
final static int maxPoolSize = 50;
// 最小逐出时间，100秒
final static int maxIdleTime = 100000;
// 连接失败重试次数
final static int retryAttempts = 10;
// 当连接池连接耗尽时获取连接数
final static int acquireIncrement = 5;
// Druid数据源
final static DruidDataSource druidDataSource = getDruidDataSource();
// 查询次数
final static int count = 10;
/**
* 测试方式： 每种数据源配置信息尽量相同，以求结果更加准确
* 每种数据源做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();
System.out.println("查询次数为：" + count);
System.out.println();
System.out.println("==========================Druid 测试开始==========================");
// 测试Druid
for (int i = 0; i < 100; i++) {
queryDruid(testDAO, druidDataSource, count);
}
System.out.println("==========================Druid 测试结束==========================");
}
/**
* Druid测试
* @param testDAO
* @param ds
* @param count
* @throws SQLException
*/
public static void queryDruid(TestDAO testDAO, DruidDataSource ds, int count) throws SQLException {
// 查询100次以初始化连接池
for (int i = 0; i < 100; 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数据源
* @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;
}
}
(4)Tomcat Jdbc Pool测试代码：
import java.io.IOException;
import java.sql.SQLException;
import org.apache.tomcat.jdbc.pool.DataSource;
public class TomcatTest {
// 数据库驱动名称
final static String driver = "com.mysql.jdbc.Driver";
// 数据库连接地址
final static String jdbcUrl = "jdbc:mysql://192.168.0.1:3306/test";
// 数据库用户名
final static String user = "dba";
// 数据库密码
final static String passwd = "dba";
// 连接池初始化大小
final static int initialSize = 5;
// 连接池最小空闲
final static int minPoolSize = 10;
// 连接池最大连接数量
final static int maxPoolSize = 50;
// 最小逐出时间，100秒
final static int maxIdleTime = 100000;
// 连接失败重试次数
final static int retryAttempts = 10;
// 当连接池连接耗尽时获取连接数
final static int acquireIncrement = 5;
// Tomcat Jdbc Pool数据源
final static DataSource tomcatDataSource = getTomcatDataSource();
// 查询次数
final static int count = 100;
/**
* 测试方式： 每种数据源配置信息尽量相同，以求结果更加准确
* 每种数据源做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();
System.out.println("查询次数为：" + count);
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 测试结束==========================");
}
/**
* Tomcat Jdbc Pool测试
* @param testDAO
* @param ds
* @param count
* @throws SQLException
*/
public static void queryTomcatJDBC(TestDAO testDAO, DataSource ds, int count) throws SQLException {
// 查询100次以初始化连接池
for (int i = 0; i < 100; 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);
}
/**
* 获取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 | 32.26 |
| Proxool | 33.42 |
| Druid | 30.43 |
| Tomcat Jdbc Pool | 37.61 |
2.测试次数为100次时：
平均用时（单位：毫秒）：
| c3p0 | 409.94 |
| Proxool | 447.49 |
| Druid | 382.7 |
| Tomcat Jdbc Pool | 386.3 |
3.测试次数为500次时：
平均用时（单位：毫秒）：
| c3p0 | 1700.95 |
| Proxool | 2053.85 |
| Druid | 1777.36 |
| Tomcat Jdbc Pool | 1749.02 |
4.测试次数为1000次时：
平均用时（单位：毫秒）：
| c3p0 | 3549.29 |
| Proxool | 3435.8 |
| Druid | 3167.59 |
| Tomcat Jdbc Pool | 3162.25 |
因为测试耗时很长，所以我只做到了1000次查询测试，感兴趣的朋友可以继续更大规模的测试或修改相应参数来符合项目自身情况，这里不比去追究测试数据的准确性，比较测试程度还不够，且存在很大的偶然性，大家可以修改以上代码进行更精准的测试，只需要将数据导入到本文末尾的excel表格中即可生成相应测试图表。
很多人总是会回复在问“你的测试准不准啊？”，“你的测试一点都不准！”等等，其实我想说的是：不要太在意别人的结果，重要的是自己去做！
相关推荐
JAVA数据库连接池（C3P0，Druid,JNDI ,DBCP,Proxool,BoneCP） 源码包含各个数据库连接池的连接DEMO spring+mybatis+maven
本例演示c3p0 、dbcp 、proxool三种常用数据库连接池的用法及log4j2日志使用方法
NULL 博文链接：https://lanyan-lan.iteye.com/blog/509140
DBPoolDemo Java jdbc pool,包含C3P0,DBCP,Proxool,Druid,tomcat-jdbc
* C3P0比较耗费资源，效率方面可能要低一点。 * DBCP在实践中存在BUG，在某些种情会产生很多空连接不能释放，Hibernate3.0已经放弃了对其的支持。 * Proxool的负面评价较少，现在比较推荐它，而且它还提供即时监控...
-- 连接池的别名 --> <alias>DBPool</alias> - <!-- proxool只能管理由自己产生的连接 --> <driver-url>jdbc:sqlserver://localhost:1433;dataBaseName=books</driver-url> - <!-- JDBC驱动程序 --> ...
proxool连接池配置详解 proxool连接池配置详解 proxool连接池配置详解 proxool连接池配置详解 proxool连接池配置详解 proxool连接池配置详解
HIbernate连接池配置总结基于第三方c3p0和proxool
三大连接池参数说明,是本人在网上查找后放在网上备份，希望也对你有用
NULL 博文链接：https://381324504-qq-com.iteye.com/blog/486480
（C3PO,proxool,dbcp,bonecp）各个连接池的配置以及用法讲解
proxool连接池使用详细说明，proxool连接池使用详细说明，proxool连接池使用详细说明。
数据库连接池包（proxool.jar）初步了解连接池的最好方式
proxool 连接池 tomcat模拟连接池
各种数据库连接池 c3p dbcp proxool
数据库连接的几种方法,连接池c3p0 ,Proxool ,Druid ,Tomcat Jdbc ...
Druid是目前最好的数据库连接池，在功能、性能、扩展性方面，都超过其他数据库连接池，包括DBCP、C3P0、BoneCP、Proxool、JBoss DataSource。Druid已经在阿里巴巴部署了超过600个应用，经过一年多生产环境大规模部署...
项目实用的proxool连接池配置文件,每个标签都有注释，可以直接拿来使用