C3P0连接池初始化过程分析之一

最新推荐文章于 2018-09-30 08:12:09 发布
最新推荐文章于 2018-09-30 08:12:09 发布
阅读量443 收藏
点赞数
文章标签： javascript 数据库 ViewUI

先把上一节的时序图拿来，强化一下印象，然后顺着图往下捋：

Created with Raphaël 2.1.0C3P0连接池初始化过程UserUserComboPooledDataSourceComboPooledDataSourceC3P0PooledConnectionPoolManagerC3P0PooledConnectionPoolManagerC3P0PooledConnectionPoolC3P0PooledConnectionPoolBasicResourcePoolBasicResourcePoolgetConnection()getPool()checkoutPooledConnection()checkoutResource()

核心类对应角色及作用

整个C3P0源码分析的第一篇应该已经介绍过了这几个核心类各自的角色及作用了，还不清楚的童鞋可以移步C3P0整体类结构简单分析去学习一下。这里就再说说它们之间的关系。

C3P0PooledConnectionPoolManager创建过程

ComboPooledDataSource与C3P0PooledConnectionPoolManager是一对一的关系，并且只会在初始化过程创建一次。C3P0PooledConnectionPoolManager的构造方法签名如下：

    public C3P0PooledConnectionPoolManager(ConnectionPoolDataSource cpds,
            Map flatPropertyOverrides, Map forceUserOverrides,
            int num_task_threads, String parentDataSourceIdentityToken,
            String parentDataSourceName) throws SQLException;

但是在ComboPooledDataSource创建C3P0PooledConnectionPoolManager的过程中，flatPropertyOverrides和forceUserOverrides都是null，所以为了看起来更清晰，下面的构造方法是简化过的版本：

    public C3P0PooledConnectionPoolManager(ConnectionPoolDataSource cpds,
            Map flatPropertyOverrides, Map forceUserOverrides,
            int num_task_threads, String parentDataSourceIdentityToken,
            String parentDataSourceName) throws SQLException {
        try {
            this.cpds = cpds;
            this.flatPropertyOverrides = flatPropertyOverrides;
            this.num_task_threads = num_task_threads;
            this.parentDataSourceIdentityToken = parentDataSourceIdentityToken;
            this.parentDataSourceName = parentDataSourceName;

            DbAuth auth = null;

            if (auth == null)
                auth = C3P0ImplUtils.findAuth(cpds);

            this.defaultAuth = auth;

            Map tmp = new HashMap();
            BeanInfo bi = Introspector.getBeanInfo(cpds.getClass());
            PropertyDescriptor[] pds = bi.getPropertyDescriptors();
            PropertyDescriptor pd = null;
            for (int i = 0, len = pds.length; i < len; ++i) {
                pd = pds[i];

                String name = pd.getName();
                Method m = pd.getReadMethod();

                if (m != null)
                    tmp.put(name, m);
            }
            this.propNamesToReadMethods = tmp;

            if (forceUserOverrides == null) {
                Method uom = (Method) propNamesToReadMethods
                        .get("userOverridesAsString");
                if (uom != null) {
                    String uoas = (String) uom.invoke(cpds, (Object[]) null);
                    Map uo = C3P0ImplUtils.parseUserOverridesAsString(uoas);
                    this.userOverrides = uo;
                } else
                    this.userOverrides = Collections.EMPTY_MAP;
            } else
                this.userOverrides = forceUserOverrides;

            poolsInit();
        } catch (Exception e) {
            if (Debug.DEBUG)
                logger.log(MLevel.FINE, null, e);
            // e.printStackTrace();
            throw SqlUtils.toSQLException(e);
        }
    }

不要被一大堆代码给吓到了，其实这个构造方法很简单，除poolsInit();这一句之外，其他的代码都在做一件事——那就是重写一些配置而已。因此我们跟踪进poolsInit();：

    private void poolsInit() {
        // 核心就这么一句，其余有些是防止热部署时内存泄露的
        maybePrivilegedPoolsInit(privilege_spawned_threads);
    }

    // 该方法也经过简化
    private void maybePrivilegedPoolsInit(final boolean privilege_spawned_threads){
        _poolsInit(); 
    }

    private synchronized void _poolsInit() {
        String idStr = idString();

        this.timer = new Timer(idStr + "-AdminTaskTimer", true);

        int matt = this.getMaxAdministrativeTaskTime();

        this.taskRunner = createTaskRunner(num_task_threads, matt, timer, idStr
                + "-HelperThread");

        int num_deferred_close_threads = this
                .getStatementCacheNumDeferredCloseThreads();

        if (num_deferred_close_threads > 0)
            this.deferredStatementDestroyer = createTaskRunner(
                    num_deferred_close_threads, matt, timer, idStr
                            + "-DeferredStatementDestroyerThread");
        else
            this.deferredStatementDestroyer = null;

        //　写死的为fasle
        if (POOL_EVENT_SUPPORT)
            this.rpfact = ResourcePoolFactory.createInstance(taskRunner, null,
                    timer);
        else
            this.rpfact = BasicResourcePoolFactory
                    .createNoEventSupportInstance(taskRunner, timer);

        this.authsToPools = new HashMap();
    }

可以看到上面最核心的方法就是_poolsInit()，我们梳理一下它做了哪些事呢：

  1. 创建定时器AdminTaskTimer
  2. 创建线程池，其中包含num_task_threads个HelperThread
  3. 可选项，缓存的statement过期销毁任务，这个只要在配置了num_deferred_close_threads 选项后才会生效
  4. 创建BasicResourcePoolFactory对象
  5. 创建缓存C3P0CollectionPool的Map

C3P0PooledConnectionPool创建过程

到这里，C3P0PooledConnectionPoolManager的创建工作就完毕了，那么下一步就是通过C3P0PooledConnectionPoolManager来创建C3P0PooledConnectionPool了。

    private C3P0PooledConnectionPool createPooledConnectionPool(DbAuth auth)
            throws SQLException {
        String userName = auth.getUser();
        String automaticTestTable = getAutomaticTestTable(userName);
        String realTestQuery;

        if (automaticTestTable != null) {
            realTestQuery = initializeAutomaticTestTable(automaticTestTable,
                    auth);
            if (this.getPreferredTestQuery(userName) != null) {
                if (logger.isLoggable(MLevel.WARNING)) {
                    logger.logp(
                            MLevel.WARNING,
                            C3P0PooledConnectionPoolManager.class.getName(),
                            "createPooledConnectionPool",
                            "[c3p0] Both automaticTestTable and preferredTestQuery have been set! "
                                    + "Using automaticTestTable, and ignoring preferredTestQuery. Real test query is ''{0}''.",
                            realTestQuery);
                }
            }
        } else {
            if (!defaultAuth.equals(auth))
                ensureFirstConnectionAcquisition(auth);

            realTestQuery = this.getPreferredTestQuery(userName);
        }

        C3P0PooledConnectionPool out = new C3P0PooledConnectionPool(cpds, auth,
                this.getMinPoolSize(userName), this.getMaxPoolSize(userName),
                this.getInitialPoolSize(userName),
                this.getAcquireIncrement(userName),
                this.getAcquireRetryAttempts(userName),
                this.getAcquireRetryDelay(userName),
                this.getBreakAfterAcquireFailure(userName),
                this.getCheckoutTimeout(userName),
                this.getIdleConnectionTestPeriod(userName),
                this.getMaxIdleTime(userName),
                this.getMaxIdleTimeExcessConnections(userName),
                this.getMaxConnectionAge(userName),
                this.getPropertyCycle(userName),
                this.getUnreturnedConnectionTimeout(userName),
                this.getDebugUnreturnedConnectionStackTraces(userName),
                this.getForceSynchronousCheckins(userName),
                this.getTestConnectionOnCheckout(userName),
                this.getTestConnectionOnCheckin(userName),
                this.getMaxStatements(userName),
                this.getMaxStatementsPerConnection(userName),
                this.getConnectionTester(userName),
                this.getConnectionCustomizer(userName), realTestQuery, rpfact,
                taskRunner, deferredStatementDestroyer,
                parentDataSourceIdentityToken);
        return out;
    }

上面的过程也很简单，如果在配置连接池时配置了automaticTestTable 参数，那么会在创建C3P0PooledConnectionPool之前先检测是否存在该表且为空表，如果没有则创建一张测试表，并且这个表是一张只包含一列的空表。这个表的目的就是为了之后检测连接有效性用的，检测过程就是用SELECT * FROM XXX，XXX为你的automaticTestTable参数值。
然后就开始调用构造方法创建C3P0PooledConnectionPool了，并且传入了一个BasicResourcePoolFactory用于让C3P0PooledConnectionPool创建BasicResourcePool：

// 这里剔除了PooledConnectionResourcePoolManager的部分
C3P0PooledConnectionPool( final ConnectionPoolDataSource cpds,
                    final DbAuth auth,
                    int min, 
                    int max, 
                    int start,
                    int inc,
                    int acq_retry_attempts,
                    int acq_retry_delay,
                    boolean break_after_acq_failure,
                    int checkoutTimeout, //milliseconds
                    int idleConnectionTestPeriod, //seconds
                    int maxIdleTime, //seconds
                    int maxIdleTimeExcessConnections, //seconds
                    int maxConnectionAge, //seconds
                    int propertyCycle, //seconds
                    int unreturnedConnectionTimeout, //seconds
                    boolean debugUnreturnedConnectionStackTraces,
                    boolean forceSynchronousCheckins,
                    final boolean testConnectionOnCheckout,
                    final boolean testConnectionOnCheckin,
                    int maxStatements,
                    int maxStatementsPerConnection,
            /* boolean statementCacheDeferredClose,      */
                    final ConnectionTester connectionTester,
                    final ConnectionCustomizer connectionCustomizer,
                    final String testQuery,
                    final ResourcePoolFactory fact,
                    ThreadPoolAsynchronousRunner taskRunner,
            ThreadPoolAsynchronousRunner deferredStatementDestroyer,
                    final String parentDataSourceIdentityToken) throws SQLException
                    {
        try
        {
            // 这个scache是用来缓存statement的，这里先不介绍
            if (maxStatements > 0 && maxStatementsPerConnection > 0)
                this.scache = new DoubleMaxStatementCache( taskRunner, deferredStatementDestroyer, maxStatements, maxStatementsPerConnection );
            else if (maxStatementsPerConnection > 0)
                this.scache = new PerConnectionMaxOnlyStatementCache( taskRunner, deferredStatementDestroyer, maxStatementsPerConnection );
            else if (maxStatements > 0)
                this.scache = new GlobalMaxOnlyStatementCache( taskRunner, deferredStatementDestroyer, maxStatements );
            else
                this.scache = null;

            // 用来检测连接有效性的Tester
            this.connectionTester = connectionTester;

            // 获取连接时的最长等待时间
            this.checkoutTimeout = checkoutTimeout;

            // 执行任务的线程池
            this.sharedTaskRunner = taskRunner;
            // 销毁过期的statement的线程
            this.deferredStatementDestroyer = deferredStatementDestroyer;

            // 这个写死为true
            this.c3p0PooledConnections = (cpds instanceof WrapperConnectionPoolDataSource);
            this.effectiveStatementCache = c3p0PooledConnections && (scache != null);

            this.inUseLockFetcher = (c3p0PooledConnections ? C3P0_POOLED_CONNECION_NESTED_LOCK_LOCK_FETCHER : RESOURCE_ITSELF_IN_USE_LOCK_FETCHER);

            class PooledConnectionResourcePoolManager implements ResourcePool.Manager
            {   
                // 省略....
            }

            ResourcePool.Manager manager = new PooledConnectionResourcePoolManager();

            synchronized (fact)
            {
                fact.setMin( min );
                fact.setMax( max );
                fact.setStart( start );
                fact.setIncrement( inc );
                fact.setIdleResourceTestPeriod( idleConnectionTestPeriod * 1000);
                fact.setResourceMaxIdleTime( maxIdleTime * 1000 );
                fact.setExcessResourceMaxIdleTime( maxIdleTimeExcessConnections * 1000 );
                fact.setResourceMaxAge( maxConnectionAge * 1000 );
                fact.setExpirationEnforcementDelay( propertyCycle * 1000 );
                fact.setDestroyOverdueResourceTime( unreturnedConnectionTimeout * 1000 );
                fact.setDebugStoreCheckoutStackTrace( debugUnreturnedConnectionStackTraces );
                fact.setForceSynchronousCheckins( forceSynchronousCheckins );
                fact.setAcquisitionRetryAttempts( acq_retry_attempts );
                fact.setAcquisitionRetryDelay( acq_retry_delay );
                fact.setBreakOnAcquisitionFailure( break_after_acq_failure );
                // 用一个ResourcePoolFactory创建出了一个ResourcePool
                rp = fact.createPool( manager );
            }
        }
        catch (ResourcePoolException e)
        { throw SqlUtils.toSQLException(e); }
    }

可以看到，在C3P0PooledConnectionPool被创建的过程中，还同时使用ResourcePoolFactory创建了一个ResourcePool，那么这个ResourcePool是用来干什么的呢？

首先我们知道，一个C3P0PooledConnectionPool对象就对应着一个数据库连接池。所以它具有各种连接池应该有的属性和方法，比如：

public PooledConnection checkoutPooledConnection() throws SQLException;

public void checkinPooledConnection(PooledConnection pcon) throws SQLException

我们就从这两个最基本的连接池方法的源码入手：

   public PooledConnection checkoutPooledConnection() throws SQLException {
        try {
            PooledConnection pc = (PooledConnection) this
                    .checkoutAndMarkConnectionInUse();
            pc.addConnectionEventListener(cl);
            return pc;
        } catch (TimeoutException e) {
            throw SqlUtils
                    .toSQLException(
                            "An attempt by a client to checkout a Connection has timed out.",
                            e);
        } catch (CannotAcquireResourceException e) {
            throw SqlUtils
                    .toSQLException(
                            "Connections could not be acquired from the underlying database!",
                            "08001", e);
        } catch (Exception e) {
            throw SqlUtils.toSQLException(e);
        }
    }

    private Object checkoutAndMarkConnectionInUse() throws TimeoutException,
            CannotAcquireResourceException, ResourcePoolException,
            InterruptedException {
        Object out = null;
        boolean success = false;
        while (!success) {
            try {
                // 这句就是取出连接的核心所在
                out = rp.checkoutResource(checkoutTimeout);
                if (out instanceof AbstractC3P0PooledConnection) {
                    // cast should succeed, because effectiveStatementCache
                    // implies c3p0 pooled Connections
                    AbstractC3P0PooledConnection acpc = (AbstractC3P0PooledConnection) out;
                    Connection physicalConnection = acpc
                            .getPhysicalConnection();
                    success = tryMarkPhysicalConnectionInUse(physicalConnection);
                } else
                    success = true; // we don't pool statements from non-c3p0
                                    // PooledConnections
            } finally {
                try {
                    if (!success && out != null)
                        rp.checkinResource(out);
                } catch (Exception e) {
                    logger
                            .log(
                                    MLevel.WARNING,
                                    "Failed to check in a Connection that was unusable due to pending Statement closes.",
                                    e);
                }
            }
        }
        return out;
    }


    public void checkinPooledConnection(PooledConnection pcon) throws SQLException
    { 
        //System.err.println(this + " -- CHECKIN");
        try 
        {
            pcon.removeConnectionEventListener( cl );
            unmarkConnectionInUseAndCheckin( pcon ); 
        } 
        catch (ResourcePoolException e)
        { throw SqlUtils.toSQLException(e); }
    }

    private void unmarkConnectionInUseAndCheckin(PooledConnection pcon) throws ResourcePoolException
    {
        if (effectiveStatementCache)
        {
            try
            {
                // cast should generally succeed, because effectiveStatementCache implies c3p0 pooled Connections
                // but clients can try to check-in whatever they want, so there are potential failures here
                AbstractC3P0PooledConnection acpc = (AbstractC3P0PooledConnection) pcon;
                Connection physicalConnection = acpc.getPhysicalConnection();
                unmarkPhysicalConnectionInUse(physicalConnection);
            }
            catch (ClassCastException e)
            {
                if (logger.isLoggable(MLevel.SEVERE))
                    logger.log(MLevel.SEVERE, 
                               "You are checking a non-c3p0 PooledConnection implementation into" +
                               "a c3p0 PooledConnectionPool instance that expects only c3p0-generated PooledConnections." +
                               "This isn't good, and may indicate a c3p0 bug, or an unusual (and unspported) use " +
                               "of the c3p0 library.", e);
            }
       }
       // 这句就是放回连接的核心所在
       rp.checkinResource(pcon);
    }

我们发现，其实所有关于连接池中的操作其实都是委托给了BasicResourcePool这个类来完成，并且这个类还有一个帮手，叫做BasicResourcePoolManager，实现了ResourcePool.Manager接口。当然这两个类在连接池初始化过程中也非常重要，详细讲起来可能又会占用大量篇幅，所以这篇文章先到这里。关于这两个类我们下一篇博客再做分析

<script type="text/javascript"> $(function () { $('pre.prettyprint code').each(function () { var lines = $(this).text().split('\n').length; var $numbering = $('<ul/>').addClass('pre-numbering').hide(); $(this).addClass('has-numbering').parent().append($numbering); for (i = 1; i <= lines; i++) { $numbering.append($('<li/>').text(i)); }; $numbering.fadeIn(1700); }); }); </script>
iteye_69
关注
c3p0 服务启动获取连接超时_JDBC连接超时无法重新连接
weixin_39722025的博客
12-24 598
I have my Spring Hibernate web application running on MySQL that gives me trouble.I have searched around and tried different configurations, read quite a few threads on this website, but it still pops...
C3P0连接池初始化设置
林妹妹的后花园
07-17 2182
1：配置web.xml文件，将初始化文件config_db.properties放进ServletContext, 监听器将从ServletContext调用初始化文件，对SQL进行初始化，这个过程随服务器开启而开启，随服务器停用而销毁。 &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;web-app xmlns:xsi="http://www...
线程池c3p0和dbcp2的配置初始化实例
weixin_34368949的博客
03-21 111
一、c3p0 public class ConnectionManager { public static ComboPooledDataSource dataSource; static { try { dataSource = new ComboPooledDataSource(); dataSource.se...
C3P0 DriverManagerDataSource初始化
Donald_Draper
12-08 476
WeakHashMap:[url]http://mikewang.blog.51cto.com/3826268/880775/[/url] WeakReference ：[url]http://blog.csdn.net/matrix_xu/article/details/8424038[/url] C3P0 ComboPooledDataSource初始化：[url]http://dona...
C3P0初始化物理数据库连接时机
XCMercy
08-03 315
存放数据库物理连接的容器 C3P0PooledConnectionPoolManager.getPool() -&amp;amp;gt; C3P0PooledConnectionPool -&amp;amp;gt; ResourcePool(BasicResourcePool) rp -&amp;amp;gt; HashMap managed 存放数据库物理连接的容器其本质是BasicResourcePool对象中的managed属性，类...
C3P0异常处理
lzy_persist的专栏
08-08 5996
C3P0异常如下： Exception in thread "C3P0PooledConnectionPoolManager[identityToken->1hge3c68wprq6h71q54sml|2110fc]-AdminTaskTimer" java.lang.NullPointerException at com.mchange.v2.log.log4j.Log4jMLog$Log4
C3P0连接池jar包(正式).zip
12-09
C3P0是一个开源的Java数据库连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。在Java应用程序中，数据库连接池扮演着非常重要的角色，它能够有效地管理数据库连接，提高系统性能，减少数据库资源...
c3p0连接池jar包
03-28
1. 连接池管理：C3P0通过初始化配置参数，如最小连接数、最大连接数等，动态地管理数据库连接池。当应用程序需要数据库连接时，可以从池中获取；使用完毕后，连接会返回到池中，供其他线程复用。 2. 自动检测与回收...
C3P0连接池初始化过程分析之二
懒人的博客
11-27 4131
上一篇我们讲到了C3P0PooledConnectionPool，并且最后说到C3P0PooledConnectionPool中的很多关于连接的操作都委托给了BasicResourcePool来处理，那么下面就隆重请出今天的主角——BasicResourcePool及其帮手——BasicResourcePoolManager。不过写了半天觉得BasicResourcePoolManager的结构和
C3p0连接池的两个配套jar包.rar_C3P0_C3p0连接池的两个配套jar包
09-23
C3p0是一个开源的Java连接池库，它实现了数据源和JNDI绑定，用于管理数据库连接。在Java应用程序中，特别是在企业级应用中，有效地管理数据库连接是非常重要的，因为这直接影响到系统的性能和稳定性。C3p0提供了一种...
c3p0连接池的基本配置
qq_25956141的博客
02-25 269
bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">                          property name="user" value="${username}"/>                          property name="password" value=
C3P0整体类结构简单分析
iteye_69的博客
10-18 305
直接进入主题吧： 这张图只是C3P0的部分结构类图，不急，先对总体上有一个了解。 首先我们需要了解，C3P0是“懒初始化”的。也就是说它并不会自己初始化，而是会等到第一个连接请求进来之后它才会初始化。而那个触发点就是： ComboPooledDataSource.getConnection(); 了解上面说的“懒初始化”之后，我们来介绍C3P0中几个主要的类： ComboPo...
C3P0连接池连接异常错误解决
热门推荐
lddongyu
07-01 2万+
转自：http://hi.baidu.com/zhenuu/blog/item/b91661385ca23d2a96ddd871.html
初始C3P0连接池
五彩世界的博客
05-11 193
C3P0连接池只需要一个jar包：其中我们可以看到有三个jar包；属于C3P0的jar包只有一个，另外两个是测试时使用的JDBC驱动：一个是mysql的，一个是oracle的；可以看到在src下我们有一个xml文件，在C3P0中我们可以通过xml配置参数，同样也可以像DBCP中使用properties文件，但是properties文件中只能写一个数据库连接，xml配置就更为灵活了，可以写多个连接（...
DBCP,c3p0连接池所需要的包
07-01
3. 初始化数据源：在应用启动时初始化数据源，如使用BasicDataSource或 ComboPooledDataSource（c3p0的类）。 4. 获取和释放连接：在需要时从数据源获取连接，在使用完毕后立即归还连接。 总结来说，DBCP和c3p0是两...
mysql的时区错误问题
weixin_33949359的博客
09-30 169
报错： The server time zone value 'Öйú±ê׼ʱ¼ä' is unrecognized or repre java.sql.SQLException: The server time zone value 'Öйú±ê׼ʱ¼ä' is unrecognized or represents more than one time zone. You must ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值