java 常见连接池性能测试

使用druid官方的 Case1 测试，但是不好用，我需要改造一下源码：

/*
 * Copyright 1999-2018 Alibaba Group Holding Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.alibaba.druid.benckmark.pool;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicLong;

import javax.sql.DataSource;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import junit.framework.TestCase;

import org.apache.commons.dbcp.BasicDataSource;

import com.alibaba.druid.mock.MockDriver;
import com.alibaba.druid.pool.DruidDataSource;
import com.jolbox.bonecp.BoneCPDataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.slf4j.ILoggerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * TestOnBo 类Case1.java的实现描述：TODO 类实现描述
 *
 * @author admin 2011-5-28 下午03:47:40
 */
public class Case1 extends TestCase {

    private String            jdbcUrl;
    private String            user;
    private String            password;
    private String            driverClass;
    private int               initialSize      = 10;
    private int               minPoolSize      = 10;
    private int               maxPoolSize      = 50; // 数据库连接处允许的最大连接数
    private int               maxActive        = maxPoolSize;// 貌似已经废弃
    private String            validationQuery  = "SELECT 1";
    private int               concurrent_threadCount = 10; // 并发线程数
    private int               loopCount        = 10;       //总测试次数
    //    final int                 LOOP_COUNT       = 1000 * 1 * 1 / threadCount;
    final int                 OPEN_CONN_COUNT = 10000 * 1 * 1;// 获取、关闭连接数


    private static AtomicLong physicalConnStat = new AtomicLong();

    public static class TestDriver extends MockDriver {

        public static TestDriver instance = new TestDriver();

        public boolean acceptsURL(String url) throws SQLException {
            if (url.startsWith("jdbc:test:")) {
                return true;
            }
            return super.acceptsURL(url);
        }

        public Connection connect(String url, Properties info) throws SQLException {
            physicalConnStat.incrementAndGet();
            return super.connect("jdbc:mock:case1", info);
        }
    }

    protected void setUp() throws Exception {
        DriverManager.registerDriver(TestDriver.instance);

        user = "dragoon25";
        password = "dragoon25";

        // jdbcUrl = "jdbc:h2:mem:";
        // driverClass = "org.h2.Driver";
        jdbcUrl = "jdbc:test:case1:";
        driverClass = "com.alibaba.druid.benckmark.pool.Case1$TestDriver";

        physicalConnStat.set(0);

        Logger LOGGER = LoggerFactory.getLogger(HikariConfig.class);
        ILoggerFactory iLoggerFactory = LoggerFactory.getILoggerFactory();
//        LOGGER.isDebugEnabled()
    }

    public void test_druid() throws Exception {
        DruidDataSource dataSource = new DruidDataSource();

        dataSource.setInitialSize(initialSize);
        dataSource.setMaxActive(maxActive);
        dataSource.setMinIdle(minPoolSize);
        dataSource.setMaxIdle(maxPoolSize);
        dataSource.setPoolPreparedStatements(true);
        dataSource.setDriverClassName(driverClass);
        dataSource.setUrl(jdbcUrl);
        dataSource.setPoolPreparedStatements(true);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        dataSource.setValidationQuery(validationQuery);
        dataSource.setTestOnBorrow(false);

        long startMillis = System.currentTimeMillis();
        for (int i = 0; i < loopCount; ++i) {
            p0(dataSource, "druid", concurrent_threadCount);
        }
        long millis = System.currentTimeMillis() - startMillis;
        System.out.println("elipse druid millis = " + millis);
        System.out.println();
    }

    public void test_dbcp() throws Exception {
        final BasicDataSource dataSource = new BasicDataSource();

        dataSource.setInitialSize(initialSize);
        dataSource.setMaxActive(maxActive);
        dataSource.setMinIdle(minPoolSize);
        dataSource.setMaxIdle(maxPoolSize);
        dataSource.setPoolPreparedStatements(true);
        dataSource.setDriverClassName(driverClass);
        dataSource.setUrl(jdbcUrl);
        dataSource.setPoolPreparedStatements(true);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        dataSource.setValidationQuery("SELECT 1");
        dataSource.setTestOnBorrow(false);

        long startMillis = System.currentTimeMillis();
        for (int i = 0; i < loopCount; ++i) {
            p0(dataSource, "dbcp", concurrent_threadCount);
        }
        long millis = System.currentTimeMillis() - startMillis;
        System.out.println("elipse dbcp millis = " + millis);
        System.out.println();
    }

    public void test_bonecp() throws Exception {
        BoneCPDataSource dataSource = new BoneCPDataSource();
        // dataSource.(10);
        // dataSource.setMaxActive(50);
        dataSource.setMinConnectionsPerPartition(minPoolSize);
        dataSource.setMaxConnectionsPerPartition(maxPoolSize);

        dataSource.setDriverClass(driverClass);
        dataSource.setJdbcUrl(jdbcUrl);
        dataSource.setStatementsCacheSize(100);
        dataSource.setServiceOrder("LIFO");
        // dataSource.setMaxOpenPreparedStatements(100);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        // dataSource.setConnectionTestStatement("SELECT 1");
        dataSource.setPartitionCount(1);
        dataSource.setAcquireIncrement(5);
        dataSource.setIdleConnectionTestPeriod(0L);
        // dataSource.setDisableConnectionTracking(true);

        long startMillis = System.currentTimeMillis();
        for (int i = 0; i < loopCount; ++i) {
            p0(dataSource, "boneCP", concurrent_threadCount);
        }
        long millis = System.currentTimeMillis() - startMillis;
        System.out.println("elipse boneCP millis = " + millis);
        System.out.println();
    }

    public void test_c3p0() throws Exception {
        ComboPooledDataSource dataSource = new ComboPooledDataSource();
        // dataSource.(10);
        // dataSource.setMaxActive(50);
        dataSource.setMinPoolSize(minPoolSize);
        dataSource.setMaxPoolSize(maxPoolSize);

        dataSource.setDriverClass(driverClass);
        dataSource.setJdbcUrl(jdbcUrl);
        // dataSource.setPoolPreparedStatements(true);
        // dataSource.setMaxOpenPreparedStatements(100);
        dataSource.setUser(user);
        dataSource.setPassword(password);

        long startMillis = System.currentTimeMillis();
        for (int i = 0; i < loopCount; ++i) {
            p0(dataSource, "c3p0", concurrent_threadCount);
        }
        long millis = System.currentTimeMillis() - startMillis;
        System.out.println("elipse c3p0 millis = " + millis);
        System.out.println();
    }

    public void test_tomcat_jdbc() throws Exception {
        org.apache.tomcat.jdbc.pool.DataSource dataSource = new org.apache.tomcat.jdbc.pool.DataSource();
        // dataSource.(10);
        dataSource.setMaxIdle(maxPoolSize);
        dataSource.setMinIdle(minPoolSize);
        dataSource.setMaxActive(maxActive);

        dataSource.setDriverClassName(driverClass);
        dataSource.setUrl(jdbcUrl);
        // dataSource.setPoolPreparedStatements(true);
        // dataSource.setMaxOpenPreparedStatements(100);
        dataSource.setUsername(user);
        dataSource.setPassword(password);

        long startMillis = System.currentTimeMillis();
        for (int i = 0; i < loopCount; ++i) {
            p0(dataSource, "tomcat-jdbc", concurrent_threadCount);
        }
        long millis = System.currentTimeMillis() - startMillis;
        System.out.println("elipse tomcat millis = " + millis);
        System.out.println();
    }

    public void test_hikari() throws Exception {
        HikariDataSource dataSource = new HikariDataSource();
        dataSource.setLogWriter(new PrintWriter(System.out));
        // dataSource.(10);
        dataSource.setMinimumIdle(minPoolSize);
        dataSource.setMaximumPoolSize(maxPoolSize);

        dataSource.setDriverClassName(driverClass);
        dataSource.setJdbcUrl(jdbcUrl);
        // dataSource.setPoolPreparedStatements(true);
        // dataSource.setMaxOpenPreparedStatements(100);
        dataSource.setUsername(user);
        dataSource.setPassword(password);

        long startMillis = System.currentTimeMillis();
        for (int i = 0; i < loopCount; ++i) {
            p0(dataSource, "hikari", concurrent_threadCount);
        }
        long millis = System.currentTimeMillis() - startMillis;
        System.out.println("elipse hikari millis = " + millis);
        System.out.println();
    }

    private void p0(final DataSource dataSource, String name, int threadCount) throws Exception {

        final CountDownLatch startLatch = new CountDownLatch(1);
        final CountDownLatch endLatch = new CountDownLatch(threadCount);
        final CountDownLatch dumpLatch = new CountDownLatch(1);

        Thread[] threads = new Thread[threadCount];
        for (int i = 0; i < threadCount; ++i) {
            Thread thread = new Thread() {

                public void run() {
                    try {
                        startLatch.await();

                        for (int i = 0; i < OPEN_CONN_COUNT; ++i) {
                            Connection conn = dataSource.getConnection();
//                            Thread.sleep(5);
                            conn.close();
                        }
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                    endLatch.countDown();

//                    try {
//                        dumpLatch.await();
//                    } catch (InterruptedException e) {
//                        e.printStackTrace();
//                    }
                }
            };
            threads[i] = thread;
            thread.start();
        }
//        long startMillis = System.currentTimeMillis();
//        long startYGC = TestUtil.getYoungGC();
//        long startFullGC = TestUtil.getFullGC();
        startLatch.countDown();
        endLatch.await();

//        long[] threadIdArray = new long[threads.length];
//        for (int i = 0; i < threads.length; ++i) {
//            threadIdArray[i] = threads[i].getId();
//        }
//        ThreadInfo[] threadInfoArray = ManagementFactory.getThreadMXBean().getThreadInfo(threadIdArray);
//
//        dumpLatch.countDown();
//
//        long blockedCount = 0;
//        long waitedCount = 0;
//        for (int i = 0; i < threadInfoArray.length; ++i) {
//            ThreadInfo threadInfo = threadInfoArray[i];
//            blockedCount += threadInfo.getBlockedCount();
//            waitedCount += threadInfo.getWaitedCount();
//        }

//        long millis = System.currentTimeMillis() - startMillis;
//        long ygc = TestUtil.getYoungGC() - startYGC;
//        long fullGC = TestUtil.getFullGC() - startFullGC;

//        System.out.println("thread " + threadCount + " " + name + " millis : "
//                           + NumberFormat.getInstance().format(millis)
////                            + "; YGC " + ygc + " FGC " + fullGC
//                           + " blocked "
////                           + NumberFormat.getInstance().format(blockedCount) //
////                           + " waited " + NumberFormat.getInstance().format(waitedCount) + " physicalConn "
//                           + physicalConnStat.get());

        /**
         *
         * 线程数： 10； 10 * 1000  * 10000  = 1亿
         tomcat 66533

         c3p0 292533

         dbcp 164118

         boneCP 37919

         druid 52299


         * 线程数： 20;
         tomcat 138724

         c3p0 652946

         dbcp 322209

         boneCP 79210

         druid 107242




         * 线程数： 1； 1 * 1000  * 10000  = 1000 w
         tomcat 4592

         c3p0 29852

         dbcp 5648

         boneCP 2612

         druid 3793






         * 线程数： 50  5亿
         tomcat 392707


        10 * 1000 * 1000
         tomcat 6668

         c3p0 30236

         dbcp 15214

         boneCP 3626

         druid 5168


         10 * 100 * 1000
         tomcat 700

         c3p0 2897

         dbcp 1607

         boneCP 403

         druid 536




         10 * 1000 * 100
         tomcat 1021

         c3p0 3190

         dbcp 1891

         boneCP 742

         druid 878




         50 * 1000 * 100
         tomcat 5659

         c3p0 23309

         dbcp 8999

         boneCP 3688

         druid 4255


         100 * 1000 * 100
         tomcat 20876

         c3p0 61648

         dbcp 35920

         boneCP 8028

         druid 9519


         100 * 100 * 100
         tomcat 1949

         c3p0 6404

         dbcp 3488

         boneCP 798

         druid 956



         100 * 10 * 100
         tomcat 228

         c3p0 655

         dbcp 424

         boneCP 113

         druid 121

         100 * 1000 * 100             maxPoolSize 100
         tomcat 13702

         c3p0 62240

         dbcp 36138

         boneCP 8004

         druid 9724



         100 * 100 * 100   maxPoolSize 100
         tomcat 1350

         c3p0 6051

         dbcp 3538

         boneCP 817

         druid 997


         elipse tomcat millis = 573522

         elipse c3p0 millis = 579165

         elipse dbcp millis = 574100

         elipse boneCP millis = 572465

         elipse hikari millis = 572466

         2021-09-13 11:21:59,683 [ERROR] DruidAbstractDataSource:1094 - maxIdle is deprecated
         elipse druid millis = 572866

         */
    }
}

执行结果：

可见  ，就性能而言， 其实是 boneCP 最好的， druid 其次，相差无几。 但是c3p0 真的就太差了，几乎是 druid 的6倍！

基本上，随着并发线程数 的增加， 耗时都会增加，

随着 获取、关闭连接数 的增加， 耗时都会增加，但差距拉大，其中c3p0 耗时大幅增加，boneCP 耗时最好，但 druid和boneCP 相差无几， 也表现非常好。而 hikari 表现也没有那么好。

在loopCount 很小的时候，比如loopCount = 10， OPEN_CONN_COUNT 比较大， 比如1000 或10000，  hikari 表现非常好， 是耗时最少的。

 
总之， 并不总是hikari  就性能最好，而是看情况的！为什么呢？  待续。。

虽然 boneCP 最好， 但是 它已经没人维护了，而且druid  的监控功能 真太强大了！ 一般都会选择 druid 吧！