devbox
不正经
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

阿里DruidDataSource访问RDS安全级别受限问题排查_exceptionsorter com.alibaba.druid.pool.vendor.mysq

作者：不正经 | 2024-03-29 19:11:07

赞

踩

exceptionsorter com.alibaba.druid.pool.vendor.mysqlexceptionsorter

目录

限制问题日志

错误代码跟踪 

异常问题分析

DruidDataSource源码

参考阅读

首先声明：这个锅不是 DruidDataSource的问题，请放心使用 DruidDataSource。

DS是关系型数据库服务（Relational Database Service）的简称，是一种即开即用、稳定可靠、可弹性伸缩的在线数据库服务。具有多重安全防护措施和完善的性能监控体系，并提供专业的数据库备份、恢复及优化方案，使您能专注于应用开发和业务发展。

问题描述：使用JDBC和Hikari连接RDS都可以正常启动服务，使用DruidDataSource连接RDS却启动不起来，最后是因为程序授权 license导致服务启动失败，而DruidDataSource的警告异常是系统安全级别的提示而已 。

限制问题日志

主要提示的是sun.misc.Unsafe.park(Native method) ，此问题可能是系统级别的安全限制，虽然也有AQS异常，本质上应该涉及到系统Native方法调用。

  1. sun.misc.Unsafe.park(Native Method)
  2.  java.util.concurrent.locks.LockSupport.park(LockSupport.java:175)
  3.  java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.await(AbstractQueuedSynchronizer.java:2039)
  4.  com.alibaba.druid.pool.DruidDataSource$CreateConnectionThread.run(DruidDataSource.java:2576)
  5. 17-Sep-2020 18:09:21.112 WARNING [localhost-startStop-1] org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads The web application [forestar-patrol-ywpt] appears to have started a thread named [Druid-ConnectionPool-Destroy-869651846] but has failed to stop it. This is very likely to create a memory leak. Stack trace of thread:
  6.  java.lang.Thread.sleep(Native Method)
  7.  com.alibaba.druid.pool.DruidDataSource$DestroyConnectionThread.run(DruidDataSource.java:2672)
  8. 17-Sep-2020 18:09:21.113 WARNING [localhost-startStop-1] org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads The web application [forestar-patrol-ywpt] appears to have started a thread named [fsCacheManager] but has failed to stop it. This is very likely to create a memory leak. Stack trace of thread:
  9.  java.net.SocketInputStream.socketRead0(Native Method)
  10.  java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
  11.  java.net.SocketInputStream.read(SocketInputStream.java:171)
  12.  java.net.SocketInputStream.read(SocketInputStream.java:141)
  13.  java.io.BufferedInputStream.fill(BufferedInputStream.java:246)
  14.  java.io.BufferedInputStream.read1(BufferedInputStream.java:286)
  15.  java.io.BufferedInputStream.read(BufferedInputStream.java:345)
  16.  sun.net.www.http.HttpClient.parseHTTPHeader(HttpClient.java:735)
  17.  sun.net.www.http.HttpClient.parseHTTP(HttpClient.java:678)
  18.  sun.net.www.protocol.http.HttpURLConnection.getInputStream0(HttpURLConnection.java:1587)
  19.  sun.net.www.protocol.http.HttpURLConnection.getInputStream(HttpURLConnection.java:1492)
  20.  net.sf.ehcache.util.UpdateChecker.getUpdateProperties(UpdateChecker.java:106)
  21.  net.sf.ehcache.util.UpdateChecker.doCheck(UpdateChecker.java:70)
  22.  net.sf.ehcache.util.UpdateChecker.checkForUpdate(UpdateChecker.java:60)
  23.  net.sf.ehcache.util.UpdateChecker.run(UpdateChecker.java:51)
  24.  java.util.TimerThread.mainLoop(Timer.java:555)
  25.  java.util.TimerThread.run(Timer.java:505)
  26. 17-Sep-2020 18:09:21.113 WARNING [localhost-startStop-1] org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads The web application [forestar-patrol-ywpt] appears to have started a thread named [SimplePageCachingFilter.data] but has failed to stop it. This is very likely to create a memory leak. Stack trace of thread:
  27.  sun.misc.Unsafe.park(Native Method)
  28.  java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:215)
  29.  java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2078)
  30.  java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1093)
  31.  java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809)
  32.  java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074)
  33.  java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)
  34.  java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
  35.  java.lang.Thread.run(Thread.java:748)
  36. 17-Sep-2020 18:09:21.114 WARNING [localhost-startStop-1] org.apache.catalina.loader.WebappClassLoaderBase.clearReferencesThreads The web application [forestar-patrol-ywpt] appears to have started a thread named [MedataCache.data] but has failed to stop it. This is very likely to create a memory leak. Stack trace of thread:
  37.  sun.misc.Unsafe.park(Native Method)
  38.  java.util.concurrent.locks.LockSupport.parkNanos(LockSupport.java:215)
  39.  java.util.concurrent.locks.AbstractQueuedSynchronizer$ConditionObject.awaitNanos(AbstractQueuedSynchronizer.java:2078)
  40.  java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:1093)
  41.  java.util.concurrent.ScheduledThreadPoolExecutor$DelayedWorkQueue.take(ScheduledThreadPoolExecutor.java:809)
  42.  java.util.concurrent.ThreadPoolExecutor.getTask(ThreadPoolExecutor.java:1074)
  43.  java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1134)
  44.  java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:624)
  45.  java.lang.Thread.run(Thread.java:748)

错误代码跟踪 

错误点1：

错误点2： 

异常问题分析

错误点1分析：这里是AQS队列阻塞。

 定位到park底层调用的是Native方法：这里就是将线程的进行阻塞的方法。

 setBlocker方法本身是调用本地系统Native硬件方法：

而UNSAFE的方法都是本地硬件Native方法：

问题点2是同个线程引发的问题实质上是问题1。 

DruidDataSource源码

阿里Druid项目代码：https://github.com/alibaba/druid

解决方法参考：RDS的mysql无法正常连接 ，或者更换数据源 

  1. /*
  2.  * Copyright 1999-2018 Alibaba Group Holding Ltd.
  3.  *
  4.  * Licensed under the Apache License, Version 2.0 (the "License");
  5.  * you may not use this file except in compliance with the License.
  6.  * You may obtain a copy of the License at
  7.  *
  8.  *      http://www.apache.org/licenses/LICENSE-2.0
  9.  *
  10.  * Unless required by applicable law or agreed to in writing, software
  11.  * distributed under the License is distributed on an "AS IS" BASIS,
  12.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13.  * See the License for the specific language governing permissions and
  14.  * limitations under the License.
  15.  */
  16. package com.alibaba.druid.pool;
  17.  
  18. import static com.alibaba.druid.util.Utils.getBoolean;
  19.  
  20. import java.io.Closeable;
  21. import java.security.AccessController;
  22. import java.security.PrivilegedAction;
  23. import java.sql.Connection;
  24. import java.sql.SQLException;
  25. import java.sql.Statement;
  26. import java.util.ArrayList;
  27. import java.util.Arrays;
  28. import java.util.Collections;
  29. import java.util.ConcurrentModificationException;
  30. import java.util.Date;
  31. import java.util.HashMap;
  32. import java.util.Iterator;
  33. import java.util.LinkedHashMap;
  34. import java.util.List;
  35. import java.util.Map;
  36. import java.util.Properties;
  37. import java.util.ServiceLoader;
  38. import java.util.StringTokenizer;
  39. import java.util.TimeZone;
  40. import java.util.concurrent.CountDownLatch;
  41. import java.util.concurrent.Future;
  42. import java.util.concurrent.ScheduledFuture;
  43. import java.util.concurrent.ScheduledThreadPoolExecutor;
  44. import java.util.concurrent.TimeUnit;
  45. import java.util.concurrent.atomic.AtomicLongFieldUpdater;
  46. import java.util.concurrent.locks.Lock;
  47. import java.util.concurrent.locks.ReentrantLock;
  48.  
  49. import javax.management.JMException;
  50. import javax.management.MBeanRegistration;
  51. import javax.management.MBeanServer;
  52. import javax.management.ObjectName;
  53. import javax.naming.NamingException;
  54. import javax.naming.Reference;
  55. import javax.naming.Referenceable;
  56. import javax.naming.StringRefAddr;
  57. import javax.sql.ConnectionEvent;
  58. import javax.sql.ConnectionEventListener;
  59. import javax.sql.ConnectionPoolDataSource;
  60. import javax.sql.PooledConnection;
  61.  
  62. import com.alibaba.druid.Constants;
  63. import com.alibaba.druid.TransactionTimeoutException;
  64. import com.alibaba.druid.VERSION;
  65. import com.alibaba.druid.filter.AutoLoad;
  66. import com.alibaba.druid.filter.Filter;
  67. import com.alibaba.druid.filter.FilterChainImpl;
  68. import com.alibaba.druid.mock.MockDriver;
  69. import com.alibaba.druid.pool.DruidPooledPreparedStatement.PreparedStatementKey;
  70. import com.alibaba.druid.pool.vendor.DB2ExceptionSorter;
  71. import com.alibaba.druid.pool.vendor.InformixExceptionSorter;
  72. import com.alibaba.druid.pool.vendor.MSSQLValidConnectionChecker;
  73. import com.alibaba.druid.pool.vendor.MockExceptionSorter;
  74. import com.alibaba.druid.pool.vendor.MySqlExceptionSorter;
  75. import com.alibaba.druid.pool.vendor.MySqlValidConnectionChecker;
  76. import com.alibaba.druid.pool.vendor.NullExceptionSorter;
  77. import com.alibaba.druid.pool.vendor.OracleExceptionSorter;
  78. import com.alibaba.druid.pool.vendor.OracleValidConnectionChecker;
  79. import com.alibaba.druid.pool.vendor.PGExceptionSorter;
  80. import com.alibaba.druid.pool.vendor.PGValidConnectionChecker;
  81. import com.alibaba.druid.pool.vendor.SybaseExceptionSorter;
  82. import com.alibaba.druid.proxy.DruidDriver;
  83. import com.alibaba.druid.proxy.jdbc.DataSourceProxyConfig;
  84. import com.alibaba.druid.proxy.jdbc.TransactionInfo;
  85. import com.alibaba.druid.sql.ast.SQLStatement;
  86. import com.alibaba.druid.sql.ast.statement.SQLSelectQuery;
  87. import com.alibaba.druid.sql.ast.statement.SQLSelectQueryBlock;
  88. import com.alibaba.druid.sql.ast.statement.SQLSelectStatement;
  89. import com.alibaba.druid.sql.parser.SQLParserUtils;
  90. import com.alibaba.druid.sql.parser.SQLStatementParser;
  91. import com.alibaba.druid.stat.DruidDataSourceStatManager;
  92. import com.alibaba.druid.stat.JdbcDataSourceStat;
  93. import com.alibaba.druid.stat.JdbcSqlStat;
  94. import com.alibaba.druid.stat.JdbcSqlStatValue;
  95. import com.alibaba.druid.support.logging.Log;
  96. import com.alibaba.druid.support.logging.LogFactory;
  97. import com.alibaba.druid.util.JMXUtils;
  98. import com.alibaba.druid.util.JdbcConstants;
  99. import com.alibaba.druid.util.JdbcUtils;
  100. import com.alibaba.druid.util.StringUtils;
  101. import com.alibaba.druid.util.Utils;
  102. import com.alibaba.druid.wall.WallFilter;
  103. import com.alibaba.druid.wall.WallProviderStatValue;
  104.  
  105. /**
  106.  * @author ljw [ljw2083@alibaba-inc.com]
  107.  * @author wenshao [szujobs@hotmail.com]
  108.  */
  109. public class DruidDataSource extends DruidAbstractDataSource implements DruidDataSourceMBean, ManagedDataSource, Referenceable, Closeable, Cloneable, ConnectionPoolDataSource, MBeanRegistration {
  110.  
  111.     private final static Log                 LOG                       = LogFactory.getLog(DruidDataSource.class);
  112.     private static final long                serialVersionUID          = 1L;
  113.     // stats
  114.     private volatile long                    recycleErrorCount         = 0L;
  115.     private long                             connectCount              = 0L;
  116.     private long                             closeCount                = 0L;
  117.     private volatile long                    connectErrorCount         = 0L;
  118.     private long                             recycleCount              = 0L;
  119.     private long                             removeAbandonedCount      = 0L;
  120.     private long                             notEmptyWaitCount         = 0L;
  121.     private long                             notEmptySignalCount       = 0L;
  122.     private long                             notEmptyWaitNanos         = 0L;
  123.     private int                              keepAliveCheckCount       = 0;
  124.     private int                              activePeak                = 0;
  125.     private long                             activePeakTime            = 0;
  126.     private int                              poolingPeak               = 0;
  127.     private long                             poolingPeakTime           = 0;
  128.     // store
  129.     private volatile DruidConnectionHolder[] connections;
  130.     private int                              poolingCount              = 0;
  131.     private int                              activeCount               = 0;
  132.     private volatile long                    discardCount              = 0;
  133.     private int                              notEmptyWaitThreadCount   = 0;
  134.     private int                              notEmptyWaitThreadPeak    = 0;
  135.     //
  136.     private DruidConnectionHolder[]          evictConnections;
  137.     private DruidConnectionHolder[]          keepAliveConnections;
  138.  
  139.     // threads
  140.     private volatile ScheduledFuture<?>      destroySchedulerFuture;
  141.     private DestroyTask                      destroyTask;
  142.  
  143.     private volatile Future<?>               createSchedulerFuture;
  144.  
  145.     private CreateConnectionThread           createConnectionThread;
  146.     private DestroyConnectionThread          destroyConnectionThread;
  147.     private LogStatsThread                   logStatsThread;
  148.     private int                              createTaskCount;
  149.  
  150.     private final CountDownLatch             initedLatch               = new CountDownLatch(2);
  151.  
  152.     private volatile boolean                 enable                    = true;
  153.  
  154.     private boolean                          resetStatEnable           = true;
  155.     private volatile long                    resetCount                = 0L;
  156.  
  157.     private String                           initStackTrace;
  158.  
  159.     private volatile boolean                 closing                   = false;
  160.     private volatile boolean                 closed                    = false;
  161.     private long                             closeTimeMillis           = -1L;
  162.  
  163.     protected JdbcDataSourceStat             dataSourceStat;
  164.  
  165.     private boolean                          useGlobalDataSourceStat   = false;
  166.     private boolean                          mbeanRegistered           = false;
  167.     public static ThreadLocal<Long>          waitNanosLocal            = new ThreadLocal<Long>();
  168.     private boolean                          logDifferentThread        = true;
  169.     private volatile boolean                 keepAlive                 = false;
  170.     private boolean                          asyncInit                 = false;
  171.     protected boolean                        killWhenSocketReadTimeout = false;
  172.  
  173.     private static List<Filter>              autoFilters               = null;
  174.     private boolean                          loadSpifilterSkip         = false;
  175.  
  176.     protected static final AtomicLongFieldUpdater<DruidDataSource> recycleErrorCountUpdater
  177.             = AtomicLongFieldUpdater.newUpdater(DruidDataSource.class, "recycleErrorCount");
  178.     protected static final AtomicLongFieldUpdater<DruidDataSource> connectErrorCountUpdater
  179.             = AtomicLongFieldUpdater.newUpdater(DruidDataSource.class, "connectErrorCount");
  180.     protected static final AtomicLongFieldUpdater<DruidDataSource> resetCountUpdater
  181.             = AtomicLongFieldUpdater.newUpdater(DruidDataSource.class, "resetCount");
  182.  
  183.  
  184.     public DruidDataSource(){
  185.         this(false);
  186.     }
  187.  
  188.     public DruidDataSource(boolean fairLock){
  189.         super(fairLock);
  190.  
  191.         configFromPropety(System.getProperties());
  192.     }
  193.  
  194.     public boolean isAsyncInit() {
  195.         return asyncInit;
  196.     }
  197.  
  198.     public void setAsyncInit(boolean asyncInit) {
  199.         this.asyncInit = asyncInit;
  200.     }
  201.  
  202.     public void configFromPropety(Properties properties) {
  203.         {
  204.             String property = properties.getProperty("druid.name");
  205.             if (property != null) {
  206.                 this.setName(property);
  207.             }
  208.         }
  209.         {
  210.             String property = properties.getProperty("druid.url");
  211.             if (property != null) {
  212.                 this.setUrl(property);
  213.             }
  214.         }
  215.         {
  216.             String property = properties.getProperty("druid.username");
  217.             if (property != null) {
  218.                 this.setUsername(property);
  219.             }
  220.         }
  221.         {
  222.             String property = properties.getProperty("druid.password");
  223.             if (property != null) {
  224.                 this.setPassword(property);
  225.             }
  226.         }
  227.         {
  228.             Boolean value = getBoolean(properties, "druid.testWhileIdle");
  229.             if (value != null) {
  230.                 this.testWhileIdle = value;
  231.             }
  232.         }
  233.         {
  234.             Boolean value = getBoolean(properties, "druid.testOnBorrow");
  235.             if (value != null) {
  236.                 this.testOnBorrow = value;
  237.             }
  238.         }
  239.         {
  240.             String property = properties.getProperty("druid.validationQuery");
  241.             if (property != null && property.length() > 0) {
  242.                 this.setValidationQuery(property);
  243.             }
  244.         }
  245.         {
  246.             Boolean value = getBoolean(properties, "druid.useGlobalDataSourceStat");
  247.             if (value != null) {
  248.                 this.setUseGlobalDataSourceStat(value);
  249.             }
  250.         }
  251.         {
  252.             Boolean value = getBoolean(properties, "druid.useGloalDataSourceStat"); // compatible for early versions
  253.             if (value != null) {
  254.                 this.setUseGlobalDataSourceStat(value);
  255.             }
  256.         }
  257.         {
  258.             Boolean value = getBoolean(properties, "druid.asyncInit"); // compatible for early versions
  259.             if (value != null) {
  260.                 this.setAsyncInit(value);
  261.             }
  262.         }
  263.         {
  264.             String property = properties.getProperty("druid.filters");
  265.  
  266.             if (property != null && property.length() > 0) {
  267.                 try {
  268.                     this.setFilters(property);
  269.                 } catch (SQLException e) {
  270.                     LOG.error("setFilters error", e);
  271.                 }
  272.             }
  273.         }
  274.         {
  275.             String property = properties.getProperty(Constants.DRUID_TIME_BETWEEN_LOG_STATS_MILLIS);
  276.             if (property != null && property.length() > 0) {
  277.                 try {
  278.                     long value = Long.parseLong(property);
  279.                     this.setTimeBetweenLogStatsMillis(value);
  280.                 } catch (NumberFormatException e) {
  281.                     LOG.error("illegal property '" + Constants.DRUID_TIME_BETWEEN_LOG_STATS_MILLIS + "'", e);
  282.                 }
  283.             }
  284.         }
  285.         {
  286.             String property = properties.getProperty(Constants.DRUID_STAT_SQL_MAX_SIZE);
  287.             if (property != null && property.length() > 0) {
  288.                 try {
  289.                     int value = Integer.parseInt(property);
  290.                     if (dataSourceStat != null) {
  291.                         dataSourceStat.setMaxSqlSize(value);
  292.                     }
  293.                 } catch (NumberFormatException e) {
  294.                     LOG.error("illegal property '" + Constants.DRUID_STAT_SQL_MAX_SIZE + "'", e);
  295.                 }
  296.             }
  297.         }
  298.         {
  299.             Boolean value = getBoolean(properties, "druid.clearFiltersEnable");
  300.             if (value != null) {
  301.                 this.setClearFiltersEnable(value);
  302.             }
  303.         }
  304.         {
  305.             Boolean value = getBoolean(properties, "druid.resetStatEnable");
  306.             if (value != null) {
  307.                 this.setResetStatEnable(value);
  308.             }
  309.         }
  310.         {
  311.             String property = properties.getProperty("druid.notFullTimeoutRetryCount");
  312.             if (property != null && property.length() > 0) {
  313.                 try {
  314.                     int value = Integer.parseInt(property);
  315.                     this.setNotFullTimeoutRetryCount(value);
  316.                 } catch (NumberFormatException e) {
  317.                     LOG.error("illegal property 'druid.notFullTimeoutRetryCount'", e);
  318.                 }
  319.             }
  320.         }
  321.         {
  322.             String property = properties.getProperty("druid.timeBetweenEvictionRunsMillis");
  323.             if (property != null && property.length() > 0) {
  324.                 try {
  325.                     long value = Long.parseLong(property);
  326.                     this.setTimeBetweenEvictionRunsMillis(value);
  327.                 } catch (NumberFormatException e) {
  328.                     LOG.error("illegal property 'druid.timeBetweenEvictionRunsMillis'", e);
  329.                 }
  330.             }
  331.         }
  332.         {
  333.             String property = properties.getProperty("druid.maxWaitThreadCount");
  334.             if (property != null && property.length() > 0) {
  335.                 try {
  336.                     int value = Integer.parseInt(property);
  337.                     this.setMaxWaitThreadCount(value);
  338.                 } catch (NumberFormatException e) {
  339.                     LOG.error("illegal property 'druid.maxWaitThreadCount'", e);
  340.                 }
  341.             }
  342.         }
  343.         {
  344.             String property = properties.getProperty("druid.maxWait");
  345.             if (property != null && property.length() > 0) {
  346.                 try {
  347.                     int value = Integer.parseInt(property);
  348.                     this.setMaxWait(value);
  349.                 } catch (NumberFormatException e) {
  350.                     LOG.error("illegal property 'druid.maxWait'", e);
  351.                 }
  352.             }
  353.         }
  354.         {
  355.             Boolean value = getBoolean(properties, "druid.failFast");
  356.             if (value != null) {
  357.                 this.setFailFast(value);
  358.             }
  359.         }
  360.         {
  361.             String property = properties.getProperty("druid.phyTimeoutMillis");
  362.             if (property != null && property.length() > 0) {
  363.                 try {
  364.                     long value = Long.parseLong(property);
  365.                     this.setPhyTimeoutMillis(value);
  366.                 } catch (NumberFormatException e) {
  367.                     LOG.error("illegal property 'druid.phyTimeoutMillis'", e);
  368.                 }
  369.             }
  370.         }
  371.         {
  372.             String property = properties.getProperty("druid.phyMaxUseCount");
  373.             if (property != null && property.length() > 0) {
  374.                 try {
  375.                     long value = Long.parseLong(property);
  376.                     this.setPhyMaxUseCount(value);
  377.                 } catch (NumberFormatException e) {
  378.                     LOG.error("illegal property 'druid.phyMaxUseCount'", e);
  379.                 }
  380.             }
  381.         }
  382.         {
  383.             String property = properties.getProperty("druid.minEvictableIdleTimeMillis");
  384.             if (property != null && property.length() > 0) {
  385.                 try {
  386.                     long value = Long.parseLong(property);
  387.                     this.setMinEvictableIdleTimeMillis(value);
  388.                 } catch (NumberFormatException e) {
  389.                     LOG.error("illegal property 'druid.minEvictableIdleTimeMillis'", e);
  390.                 }
  391.             }
  392.         }
  393.         {
  394.             String property = properties.getProperty("druid.maxEvictableIdleTimeMillis");
  395.             if (property != null && property.length() > 0) {
  396.                 try {
  397.                     long value = Long.parseLong(property);
  398.                     this.setMaxEvictableIdleTimeMillis(value);
  399.                 } catch (NumberFormatException e) {
  400.                     LOG.error("illegal property 'druid.maxEvictableIdleTimeMillis'", e);
  401.                 }
  402.             }
  403.         }
  404.         {
  405.             Boolean value = getBoolean(properties, "druid.keepAlive");
  406.             if (value != null) {
  407.                 this.setKeepAlive(value);
  408.             }
  409.         }
  410.         {
  411.             String property = properties.getProperty("druid.keepAliveBetweenTimeMillis");
  412.             if (property != null && property.length() > 0) {
  413.                 try {
  414.                     long value = Long.parseLong(property);
  415.                     this.setKeepAliveBetweenTimeMillis(value);
  416.                 } catch (NumberFormatException e) {
  417.                     LOG.error("illegal property 'druid.keepAliveBetweenTimeMillis'", e);
  418.                 }
  419.             }
  420.         }
  421.         {
  422.             Boolean value = getBoolean(properties, "druid.poolPreparedStatements");
  423.             if (value != null) {
  424.                 this.setPoolPreparedStatements0(value);
  425.             }
  426.         }
  427.         {
  428.             Boolean value = getBoolean(properties, "druid.initVariants");
  429.             if (value != null) {
  430.                 this.setInitVariants(value);
  431.             }
  432.         }
  433.         {
  434.             Boolean value = getBoolean(properties, "druid.initGlobalVariants");
  435.             if (value != null) {
  436.                 this.setInitGlobalVariants(value);
  437.             }
  438.         }
  439.         {
  440.             Boolean value = getBoolean(properties, "druid.useUnfairLock");
  441.             if (value != null) {
  442.                 this.setUseUnfairLock(value);
  443.             }
  444.         }
  445.         {
  446.             String property = properties.getProperty("druid.driverClassName");
  447.             if (property != null) {
  448.                 this.setDriverClassName(property);
  449.             }
  450.         }
  451.         {
  452.             String property = properties.getProperty("druid.initialSize");
  453.             if (property != null && property.length() > 0) {
  454.                 try {
  455.                     int value = Integer.parseInt(property);
  456.                     this.setInitialSize(value);
  457.                 } catch (NumberFormatException e) {
  458.                     LOG.error("illegal property 'druid.initialSize'", e);
  459.                 }
  460.             }
  461.         }
  462.         {
  463.             String property = properties.getProperty("druid.minIdle");
  464.             if (property != null && property.length() > 0) {
  465.                 try {
  466.                     int value = Integer.parseInt(property);
  467.                     this.setMinIdle(value);
  468.                 } catch (NumberFormatException e) {
  469.                     LOG.error("illegal property 'druid.minIdle'", e);
  470.                 }
  471.             }
  472.         }
  473.         {
  474.             String property = properties.getProperty("druid.maxActive");
  475.             if (property != null && property.length() > 0) {
  476.                 try {
  477.                     int value = Integer.parseInt(property);
  478.                     this.setMaxActive(value);
  479.                 } catch (NumberFormatException e) {
  480.                     LOG.error("illegal property 'druid.maxActive'", e);
  481.                 }
  482.             }
  483.         }
  484.         {
  485.             Boolean value = getBoolean(properties, "druid.killWhenSocketReadTimeout");
  486.             if (value != null) {
  487.                 setKillWhenSocketReadTimeout(value);
  488.             }
  489.         }
  490.         {
  491.             String property = properties.getProperty("druid.connectProperties");
  492.             if (property != null) {
  493.                 this.setConnectionProperties(property);
  494.             }
  495.         }
  496.         {
  497.             String property = properties.getProperty("druid.maxPoolPreparedStatementPerConnectionSize");
  498.             if (property != null && property.length() > 0) {
  499.                 try {
  500.                     int value = Integer.parseInt(property);
  501.                     this.setMaxPoolPreparedStatementPerConnectionSize(value);
  502.                 } catch (NumberFormatException e) {
  503.                     LOG.error("illegal property 'druid.maxPoolPreparedStatementPerConnectionSize'", e);
  504.                 }
  505.             }
  506.         }
  507.         {
  508.             String property = properties.getProperty("druid.initConnectionSqls");
  509.             if (property != null && property.length() > 0) {
  510.                 try {
  511.                     StringTokenizer tokenizer = new StringTokenizer(property, ";");
  512.                     setConnectionInitSqls(Collections.list(tokenizer));
  513.                 } catch (NumberFormatException e) {
  514.                     LOG.error("illegal property 'druid.initConnectionSqls'", e);
  515.                 }
  516.             }
  517.         }
  518.         {
  519.             String property = System.getProperty("druid.load.spifilter.skip");
  520.             if (property != null && !"false".equals(property)) {
  521.                 loadSpifilterSkip = true;
  522.             }
  523.         }
  524.     }
  525.  
  526.     public boolean isKillWhenSocketReadTimeout() {
  527.         return killWhenSocketReadTimeout;
  528.     }
  529.  
  530.     public void setKillWhenSocketReadTimeout(boolean killWhenSocketTimeOut) {
  531.         this.killWhenSocketReadTimeout = killWhenSocketTimeOut;
  532.     }
  533.  
  534.     public boolean isUseGlobalDataSourceStat() {
  535.         return useGlobalDataSourceStat;
  536.     }
  537.  
  538.     public void setUseGlobalDataSourceStat(boolean useGlobalDataSourceStat) {
  539.         this.useGlobalDataSourceStat = useGlobalDataSourceStat;
  540.     }
  541.  
  542.     public boolean isKeepAlive() {
  543.         return keepAlive;
  544.     }
  545.  
  546.     public void setKeepAlive(boolean keepAlive) {
  547.         this.keepAlive = keepAlive;
  548.     }
  549.  
  550.     public String getInitStackTrace() {
  551.         return initStackTrace;
  552.     }
  553.  
  554.     public boolean isResetStatEnable() {
  555.         return resetStatEnable;
  556.     }
  557.  
  558.     public void setResetStatEnable(boolean resetStatEnable) {
  559.         this.resetStatEnable = resetStatEnable;
  560.         if (dataSourceStat != null) {
  561.             dataSourceStat.setResetStatEnable(resetStatEnable);
  562.         }
  563.     }
  564.  
  565.     public long getDiscardCount() {
  566.         return discardCount;
  567.     }
  568.  
  569.     public void restart() throws SQLException {
  570.         lock.lock();
  571.         try {
  572.             if (activeCount > 0) {
  573.                 throw new SQLException("can not restart, activeCount not zero. " + activeCount);
  574.             }
  575.             if (LOG.isInfoEnabled()) {
  576.                 LOG.info("{dataSource-" + this.getID() + "} restart");
  577.             }
  578.  
  579.             this.close();
  580.             this.resetStat();
  581.             this.inited = false;
  582.             this.enable = true;
  583.             this.closed = false;
  584.         } finally {
  585.             lock.unlock();
  586.         }
  587.     }
  588.  
  589.     public void resetStat() {
  590.         if (!isResetStatEnable()) {
  591.             return;
  592.         }
  593.  
  594.         lock.lock();
  595.         try {
  596.             connectCount = 0;
  597.             closeCount = 0;
  598.             discardCount = 0;
  599.             recycleCount = 0;
  600.             createCount = 0L;
  601.             directCreateCount = 0;
  602.             destroyCount = 0L;
  603.             removeAbandonedCount = 0;
  604.             notEmptyWaitCount = 0;
  605.             notEmptySignalCount = 0L;
  606.             notEmptyWaitNanos = 0;
  607.  
  608.             activePeak = activeCount;
  609.             activePeakTime = 0;
  610.             poolingPeak = 0;
  611.             createTimespan = 0;
  612.             lastError = null;
  613.             lastErrorTimeMillis = 0;
  614.             lastCreateError = null;
  615.             lastCreateErrorTimeMillis = 0;
  616.         } finally {
  617.             lock.unlock();
  618.         }
  619.  
  620.         connectErrorCountUpdater.set(this, 0);
  621.         errorCountUpdater.set(this, 0);
  622.         commitCountUpdater.set(this, 0);
  623.         rollbackCountUpdater.set(this, 0);
  624.         startTransactionCountUpdater.set(this, 0);
  625.         cachedPreparedStatementHitCountUpdater.set(this, 0);
  626.         closedPreparedStatementCountUpdater.set(this, 0);
  627.         preparedStatementCountUpdater.set(this, 0);
  628.         transactionHistogram.reset();
  629.         cachedPreparedStatementDeleteCountUpdater.set(this, 0);
  630.         recycleErrorCountUpdater.set(this, 0);
  631.  
  632.         resetCountUpdater.incrementAndGet(this);
  633.     }
  634.  
  635.     public long getResetCount() {
  636.         return this.resetCount;
  637.     }
  638.  
  639.     public boolean isEnable() {
  640.         return enable;
  641.     }
  642.  
  643.     public void setEnable(boolean enable) {
  644.         lock.lock();
  645.         try {
  646.             this.enable = enable;
  647.             if (!enable) {
  648.                 notEmpty.signalAll();
  649.                 notEmptySignalCount++;
  650.             }
  651.         } finally {
  652.             lock.unlock();
  653.         }
  654.     }
  655.  
  656.     public void setPoolPreparedStatements(boolean value) {
  657.         setPoolPreparedStatements0(value);
  658.     }
  659.  
  660.     private void setPoolPreparedStatements0(boolean value) {
  661.         if (this.poolPreparedStatements == value) {
  662.             return;
  663.         }
  664.  
  665.         this.poolPreparedStatements = value;
  666.  
  667.         if (!inited) {
  668.             return;
  669.         }
  670.  
  671.         if (LOG.isInfoEnabled()) {
  672.             LOG.info("set poolPreparedStatements " + this.poolPreparedStatements + " -> " + value);
  673.         }
  674.  
  675.         if (!value) {
  676.             lock.lock();
  677.             try {
  678.  
  679.                 for (int i = 0; i < poolingCount; ++i) {
  680.                     DruidConnectionHolder connection = connections[i];
  681.  
  682.                     for (PreparedStatementHolder holder : connection.getStatementPool().getMap().values()) {
  683.                         closePreapredStatement(holder);
  684.                     }
  685.  
  686.                     connection.getStatementPool().getMap().clear();
  687.                 }
  688.             } finally {
  689.                 lock.unlock();
  690.             }
  691.         }
  692.     }
  693.  
  694.     public void setMaxActive(int maxActive) {
  695.         if (this.maxActive == maxActive) {
  696.             return;
  697.         }
  698.  
  699.         if (maxActive == 0) {
  700.             throw new IllegalArgumentException("maxActive can't not set zero");
  701.         }
  702.  
  703.         if (!inited) {
  704.             this.maxActive = maxActive;
  705.             return;
  706.         }
  707.  
  708.         if (maxActive < this.minIdle) {
  709.             throw new IllegalArgumentException("maxActive less than minIdle, " + maxActive + " < " + this.minIdle);
  710.         }
  711.  
  712.         if (LOG.isInfoEnabled()) {
  713.             LOG.info("maxActive changed : " + this.maxActive + " -> " + maxActive);
  714.         }
  715.  
  716.         lock.lock();
  717.         try {
  718.             int allCount = this.poolingCount + this.activeCount;
  719.  
  720.             if (maxActive > allCount) {
  721.                 this.connections = Arrays.copyOf(this.connections, maxActive);
  722.                 evictConnections = new DruidConnectionHolder[maxActive];
  723.                 keepAliveConnections = new DruidConnectionHolder[maxActive];
  724.             } else {
  725.                 this.connections = Arrays.copyOf(this.connections, allCount);
  726.                 evictConnections = new DruidConnectionHolder[allCount];
  727.                 keepAliveConnections = new DruidConnectionHolder[allCount];
  728.             }
  729.  
  730.             this.maxActive = maxActive;
  731.         } finally {
  732.             lock.unlock();
  733.         }
  734.     }
  735.  
  736.     @SuppressWarnings("rawtypes")
  737.     public void setConnectProperties(Properties properties) {
  738.         if (properties == null) {
  739.             properties = new Properties();
  740.         }
  741.  
  742.         boolean equals;
  743.         if (properties.size() == this.connectProperties.size()) {
  744.             equals = true;
  745.             for (Map.Entry entry : properties.entrySet()) {
  746.                 Object value = this.connectProperties.get(entry.getKey());
  747.                 Object entryValue = entry.getValue();
  748.                 if (value == null && entryValue != null) {
  749.                     equals = false;
  750.                     break;
  751.                 }
  752.  
  753.                 if (!value.equals(entry.getValue())) {
  754.                     equals = false;
  755.                     break;
  756.                 }
  757.             }
  758.         } else {
  759.             equals = false;
  760.         }
  761.  
  762.         if (!equals) {
  763.             if (inited && LOG.isInfoEnabled()) {
  764.                 LOG.info("connectProperties changed : " + this.connectProperties + " -> " + properties);
  765.             }
  766.  
  767.             configFromPropety(properties);
  768.  
  769.             for (Filter filter : this.filters) {
  770.                 filter.configFromProperties(properties);
  771.             }
  772.  
  773.             if (exceptionSorter != null) {
  774.                 exceptionSorter.configFromProperties(properties);
  775.             }
  776.  
  777.             if (validConnectionChecker != null) {
  778.                 validConnectionChecker.configFromProperties(properties);
  779.             }
  780.  
  781.             if (statLogger != null) {
  782.                 statLogger.configFromProperties(properties);
  783.             }
  784.         }
  785.  
  786.         this.connectProperties = properties;
  787.     }
  788.  
  789.     public void init() throws SQLException {
  790.         if (inited) {
  791.             return;
  792.         }
  793.  
  794.         // bug fixed for dead lock, for issue #2980
  795.         DruidDriver.getInstance();
  796.  
  797.         final ReentrantLock lock = this.lock;
  798.         try {
  799.             lock.lockInterruptibly();
  800.         } catch (InterruptedException e) {
  801.             throw new SQLException("interrupt", e);
  802.         }
  803.  
  804.         boolean init = false;
  805.         try {
  806.             if (inited) {
  807.                 return;
  808.             }
  809.  
  810.             initStackTrace = Utils.toString(Thread.currentThread().getStackTrace());
  811.  
  812.             this.id = DruidDriver.createDataSourceId();
  813.             if (this.id > 1) {
  814.                 long delta = (this.id - 1) * 100000;
  815.                 this.connectionIdSeedUpdater.addAndGet(this, delta);
  816.                 this.statementIdSeedUpdater.addAndGet(this, delta);
  817.                 this.resultSetIdSeedUpdater.addAndGet(this, delta);
  818.                 this.transactionIdSeedUpdater.addAndGet(this, delta);
  819.             }
  820.  
  821.             if (this.jdbcUrl != null) {
  822.                 this.jdbcUrl = this.jdbcUrl.trim();
  823.                 initFromWrapDriverUrl();
  824.             }
  825.  
  826.             for (Filter filter : filters) {
  827.                 filter.init(this);
  828.             }
  829.  
  830.             if (this.dbType == null || this.dbType.length() == 0) {
  831.                 this.dbType = JdbcUtils.getDbType(jdbcUrl, null);
  832.             }
  833.  
  834.             if (JdbcConstants.MYSQL.equals(this.dbType)
  835.                     || JdbcConstants.MARIADB.equals(this.dbType)
  836.                     || JdbcConstants.ALIYUN_ADS.equals(this.dbType)) {
  837.                 boolean cacheServerConfigurationSet = false;
  838.                 if (this.connectProperties.containsKey("cacheServerConfiguration")) {
  839.                     cacheServerConfigurationSet = true;
  840.                 } else if (this.jdbcUrl.indexOf("cacheServerConfiguration") != -1) {
  841.                     cacheServerConfigurationSet = true;
  842.                 }
  843.                 if (cacheServerConfigurationSet) {
  844.                     this.connectProperties.put("cacheServerConfiguration", "true");
  845.                 }
  846.             }
  847.  
  848.             if (maxActive <= 0) {
  849.                 throw new IllegalArgumentException("illegal maxActive " + maxActive);
  850.             }
  851.  
  852.             if (maxActive < minIdle) {
  853.                 throw new IllegalArgumentException("illegal maxActive " + maxActive);
  854.             }
  855.  
  856.             if (getInitialSize() > maxActive) {
  857.                 throw new IllegalArgumentException("illegal initialSize " + this.initialSize + ", maxActive " + maxActive);
  858.             }
  859.  
  860.             if (timeBetweenLogStatsMillis > 0 && useGlobalDataSourceStat) {
  861.                 throw new IllegalArgumentException("timeBetweenLogStatsMillis not support useGlobalDataSourceStat=true");
  862.             }
  863.  
  864.             if (maxEvictableIdleTimeMillis < minEvictableIdleTimeMillis) {
  865.                 throw new SQLException("maxEvictableIdleTimeMillis must be grater than minEvictableIdleTimeMillis");
  866.             }
  867.  
  868.             if (this.driverClass != null) {
  869.                 this.driverClass = driverClass.trim();
  870.             }
  871.  
  872.             initFromSPIServiceLoader();
  873.  
  874.             if (this.driver == null) {
  875.                 if (this.driverClass == null || this.driverClass.isEmpty()) {
  876.                     this.driverClass = JdbcUtils.getDriverClassName(this.jdbcUrl);
  877.                 }
  878.  
  879.                 if (MockDriver.class.getName().equals(driverClass)) {
  880.                     driver = MockDriver.instance;
  881.                 } else {
  882.                     if (jdbcUrl == null && (driverClass == null || driverClass.length() == 0)) {
  883.                         throw new SQLException("url not set");
  884.                     }
  885.                     driver = JdbcUtils.createDriver(driverClassLoader, driverClass);
  886.                 }
  887.             } else {
  888.                 if (this.driverClass == null) {
  889.                     this.driverClass = driver.getClass().getName();
  890.                 }
  891.             }
  892.  
  893.             initCheck();
  894.  
  895.             initExceptionSorter();
  896.             initValidConnectionChecker();
  897.             validationQueryCheck();
  898.  
  899.             if (isUseGlobalDataSourceStat()) {
  900.                 dataSourceStat = JdbcDataSourceStat.getGlobal();
  901.                 if (dataSourceStat == null) {
  902.                     dataSourceStat = new JdbcDataSourceStat("Global", "Global", this.dbType);
  903.                     JdbcDataSourceStat.setGlobal(dataSourceStat);
  904.                 }
  905.                 if (dataSourceStat.getDbType() == null) {
  906.                     dataSourceStat.setDbType(this.dbType);
  907.                 }
  908.             } else {
  909.                 dataSourceStat = new JdbcDataSourceStat(this.name, this.jdbcUrl, this.dbType, this.connectProperties);
  910.             }
  911.             dataSourceStat.setResetStatEnable(this.resetStatEnable);
  912.  
  913.             connections = new DruidConnectionHolder[maxActive];
  914.             evictConnections = new DruidConnectionHolder[maxActive];
  915.             keepAliveConnections = new DruidConnectionHolder[maxActive];
  916.  
  917.             SQLException connectError = null;
  918.  
  919.             if (createScheduler != null && asyncInit) {
  920.                 for (int i = 0; i < initialSize; ++i) {
  921.                     createTaskCount++;
  922.                     CreateConnectionTask task = new CreateConnectionTask(true);
  923.                     this.createSchedulerFuture = createScheduler.submit(task);
  924.                 }
  925.             } else if (!asyncInit) {
  926.                 // init connections
  927.                 while (poolingCount < initialSize) {
  928.                     try {
  929.                         PhysicalConnectionInfo pyConnectInfo = createPhysicalConnection();
  930.                         DruidConnectionHolder holder = new DruidConnectionHolder(this, pyConnectInfo);
  931.                         connections[poolingCount++] = holder;
  932.                     } catch (SQLException ex) {
  933.                         LOG.error("init datasource error, url: " + this.getUrl(), ex);
  934.                         if (initExceptionThrow) {
  935.                             connectError = ex;
  936.                             break;
  937.                         } else {
  938.                             Thread.sleep(3000);
  939.                         }
  940.                     }
  941.                 }
  942.  
  943.                 if (poolingCount > 0) {
  944.                     poolingPeak = poolingCount;
  945.                     poolingPeakTime = System.currentTimeMillis();
  946.                 }
  947.             }
  948.  
  949.             createAndLogThread();
  950.             createAndStartCreatorThread();
  951.             createAndStartDestroyThread();
  952.  
  953.             initedLatch.await();
  954.             init = true;
  955.  
  956.             initedTime = new Date();
  957.             registerMbean();
  958.  
  959.             if (connectError != null && poolingCount == 0) {
  960.                 throw connectError;
  961.             }
  962.  
  963.             if (keepAlive) {
  964.                 // async fill to minIdle
  965.                 if (createScheduler != null) {
  966.                     for (int i = 0; i < minIdle; ++i) {
  967.                         createTaskCount++;
  968.                         CreateConnectionTask task = new CreateConnectionTask(true);
  969.                         this.createSchedulerFuture = createScheduler.submit(task);
  970.                     }
  971.                 } else {
  972.                     this.emptySignal();
  973.                 }
  974.             }
  975.  
  976.         } catch (SQLException e) {
  977.             LOG.error("{dataSource-" + this.getID() + "} init error", e);
  978.             throw e;
  979.         } catch (InterruptedException e) {
  980.             throw new SQLException(e.getMessage(), e);
  981.         } catch (RuntimeException e){
  982.             LOG.error("{dataSource-" + this.getID() + "} init error", e);
  983.             throw e;
  984.         } catch (Error e){
  985.             LOG.error("{dataSource-" + this.getID() + "} init error", e);
  986.             throw e;
  987.  
  988.         } finally {
  989.             inited = true;
  990.             lock.unlock();
  991.  
  992.             if (init && LOG.isInfoEnabled()) {
  993.                 String msg = "{dataSource-" + this.getID();
  994.  
  995.                 if (this.name != null && !this.name.isEmpty()) {
  996.                     msg += ",";
  997.                     msg += this.name;
  998.                 }
  999.  
  1000.                 msg += "} inited";
  1001.  
  1002.                 LOG.info(msg);
  1003.             }
  1004.         }
  1005.     }
  1006.  
  1007.     private void createAndLogThread() {
  1008.         if (this.timeBetweenLogStatsMillis <= 0) {
  1009.             return;
  1010.         }
  1011.  
  1012.         String threadName = "Druid-ConnectionPool-Log-" + System.identityHashCode(this);
  1013.         logStatsThread = new LogStatsThread(threadName);
  1014.         logStatsThread.start();
  1015.  
  1016.         this.resetStatEnable = false;
  1017.     }
  1018.  
  1019.     protected void createAndStartDestroyThread() {
  1020.         destroyTask = new DestroyTask();
  1021.  
  1022.         if (destroyScheduler != null) {
  1023.             long period = timeBetweenEvictionRunsMillis;
  1024.             if (period <= 0) {
  1025.                 period = 1000;
  1026.             }
  1027.             destroySchedulerFuture = destroyScheduler.scheduleAtFixedRate(destroyTask, period, period,
  1028.                                                                           TimeUnit.MILLISECONDS);
  1029.             initedLatch.countDown();
  1030.             return;
  1031.         }
  1032.  
  1033.         String threadName = "Druid-ConnectionPool-Destroy-" + System.identityHashCode(this);
  1034.         destroyConnectionThread = new DestroyConnectionThread(threadName);
  1035.         destroyConnectionThread.start();
  1036.     }
  1037.  
  1038.     protected void createAndStartCreatorThread() {
  1039.         if (createScheduler == null) {
  1040.             String threadName = "Druid-ConnectionPool-Create-" + System.identityHashCode(this);
  1041.             createConnectionThread = new CreateConnectionThread(threadName);
  1042.             createConnectionThread.start();
  1043.             return;
  1044.         }
  1045.  
  1046.         initedLatch.countDown();
  1047.     }
  1048.  
  1049.     /**
  1050.      * load filters from SPI ServiceLoader
  1051.      * 
  1052.      * @see ServiceLoader
  1053.      */
  1054.     private void initFromSPIServiceLoader() {
  1055.         if (loadSpifilterSkip) {
  1056.             return;
  1057.         }
  1058.  
  1059.         if (autoFilters == null) {
  1060.             List<Filter> filters = new ArrayList<Filter>();
  1061.             ServiceLoader<Filter> autoFilterLoader = ServiceLoader.load(Filter.class);
  1062.  
  1063.             for (Filter filter : autoFilterLoader) {
  1064.                 AutoLoad autoLoad = filter.getClass().getAnnotation(AutoLoad.class);
  1065.                 if (autoLoad != null && autoLoad.value()) {
  1066.                     filters.add(filter);
  1067.                 }
  1068.             }
  1069.             autoFilters = filters;
  1070.         }
  1071.  
  1072.         for (Filter filter : autoFilters) {
  1073.             if (LOG.isInfoEnabled()) {
  1074.                 LOG.info("load filter from spi :" + filter.getClass().getName());
  1075.             }
  1076.             addFilter(filter);
  1077.         }
  1078.     }
  1079.  
  1080.     private void initFromWrapDriverUrl() throws SQLException {
  1081.         if (!jdbcUrl.startsWith(DruidDriver.DEFAULT_PREFIX)) {
  1082.             return;
  1083.         }
  1084.  
  1085.         DataSourceProxyConfig config = DruidDriver.parseConfig(jdbcUrl, null);
  1086.         this.driverClass = config.getRawDriverClassName();
  1087.  
  1088.         LOG.error("error url : '" + jdbcUrl + "', it should be : '" + config.getRawUrl() + "'");
  1089.  
  1090.         this.jdbcUrl = config.getRawUrl();
  1091.         if (this.name == null) {
  1092.             this.name = config.getName();
  1093.         }
  1094.  
  1095.         for (Filter filter : config.getFilters()) {
  1096.             addFilter(filter);
  1097.         }
  1098.     }
  1099.  
  1100.     /**
  1101.      * 会去重复
  1102.      * 
  1103.      * @param filter
  1104.      */
  1105.     private void addFilter(Filter filter) {
  1106.         boolean exists = false;
  1107.         for (Filter initedFilter : this.filters) {
  1108.             if (initedFilter.getClass() == filter.getClass()) {
  1109.                 exists = true;
  1110.                 break;
  1111.             }
  1112.         }
  1113.  
  1114.         if (!exists) {
  1115.             filter.init(this);
  1116.             this.filters.add(filter);
  1117.         }
  1118.  
  1119.     }
  1120.  
  1121.     private void validationQueryCheck() {
  1122.         if (!(testOnBorrow || testOnReturn || testWhileIdle)) {
  1123.             return;
  1124.         }
  1125.  
  1126.         if (this.validConnectionChecker != null) {
  1127.             return;
  1128.         }
  1129.  
  1130.         if (this.validationQuery != null && this.validationQuery.length() > 0) {
  1131.             return;
  1132.         }
  1133.  
  1134.         String errorMessage = "";
  1135.  
  1136.         if (testOnBorrow) {
  1137.             errorMessage += "testOnBorrow is true, ";
  1138.         }
  1139.  
  1140.         if (testOnReturn) {
  1141.             errorMessage += "testOnReturn is true, ";
  1142.         }
  1143.  
  1144.         if (testWhileIdle) {
  1145.             errorMessage += "testWhileIdle is true, ";
  1146.         }
  1147.  
  1148.         LOG.error(errorMessage + "validationQuery not set");
  1149.     }
  1150.  
  1151.     protected void initCheck() throws SQLException {
  1152.         if (JdbcUtils.ORACLE.equals(this.dbType)) {
  1153.             isOracle = true;
  1154.  
  1155.             if (driver.getMajorVersion() < 10) {
  1156.                 throw new SQLException("not support oracle driver " + driver.getMajorVersion() + "."
  1157.                                        + driver.getMinorVersion());
  1158.             }
  1159.  
  1160.             if (driver.getMajorVersion() == 10 && isUseOracleImplicitCache()) {
  1161.                 this.getConnectProperties().setProperty("oracle.jdbc.FreeMemoryOnEnterImplicitCache", "true");
  1162.             }
  1163.  
  1164.             oracleValidationQueryCheck();
  1165.         } else if (JdbcUtils.DB2.equals(dbType)) {
  1166.             db2ValidationQueryCheck();
  1167.         } else if (JdbcUtils.MYSQL.equals(this.dbType)
  1168.                 || JdbcUtils.MYSQL_DRIVER_6.equals(this.dbType)) {
  1169.             isMySql = true;
  1170.         }
  1171.  
  1172.         if (removeAbandoned) {
  1173.             LOG.warn("removeAbandoned is true, not use in productiion.");
  1174.         }
  1175.     }
  1176.  
  1177.     private void oracleValidationQueryCheck() {
  1178.         if (validationQuery == null) {
  1179.             return;
  1180.         }
  1181.         if (validationQuery.length() == 0) {
  1182.             return;
  1183.         }
  1184.  
  1185.         SQLStatementParser sqlStmtParser = SQLParserUtils.createSQLStatementParser(validationQuery, this.dbType);
  1186.         List<SQLStatement> stmtList = sqlStmtParser.parseStatementList();
  1187.  
  1188.         if (stmtList.size() != 1) {
  1189.             return;
  1190.         }
  1191.  
  1192.         SQLStatement stmt = stmtList.get(0);
  1193.         if (!(stmt instanceof SQLSelectStatement)) {
  1194.             return;
  1195.         }
  1196.  
  1197.         SQLSelectQuery query = ((SQLSelectStatement) stmt).getSelect().getQuery();
  1198.         if (query instanceof SQLSelectQueryBlock) {
  1199.             if (((SQLSelectQueryBlock) query).getFrom() == null) {
  1200.                 LOG.error("invalid oracle validationQuery. " + validationQuery + ", may should be : " + validationQuery
  1201.                           + " FROM DUAL");
  1202.             }
  1203.         }
  1204.     }
  1205.  
  1206.     private void db2ValidationQueryCheck() {
  1207.         if (validationQuery == null) {
  1208.             return;
  1209.         }
  1210.         if (validationQuery.length() == 0) {
  1211.             return;
  1212.         }
  1213.  
  1214.         SQLStatementParser sqlStmtParser = SQLParserUtils.createSQLStatementParser(validationQuery, this.dbType);
  1215.         List<SQLStatement> stmtList = sqlStmtParser.parseStatementList();
  1216.  
  1217.         if (stmtList.size() != 1) {
  1218.             return;
  1219.         }
  1220.  
  1221.         SQLStatement stmt = stmtList.get(0);
  1222.         if (!(stmt instanceof SQLSelectStatement)) {
  1223.             return;
  1224.         }
  1225.  
  1226.         SQLSelectQuery query = ((SQLSelectStatement) stmt).getSelect().getQuery();
  1227.         if (query instanceof SQLSelectQueryBlock) {
  1228.             if (((SQLSelectQueryBlock) query).getFrom() == null) {
  1229.                 LOG.error("invalid db2 validationQuery. " + validationQuery + ", may should be : " + validationQuery
  1230.                           + " FROM SYSDUMMY");
  1231.             }
  1232.         }
  1233.     }
  1234.  
  1235.     private void initValidConnectionChecker() {
  1236.         if (this.validConnectionChecker != null) {
  1237.             return;
  1238.         }
  1239.  
  1240.         String realDriverClassName = driver.getClass().getName();
  1241.         if (JdbcUtils.isMySqlDriver(realDriverClassName)) {
  1242.             this.validConnectionChecker = new MySqlValidConnectionChecker();
  1243.  
  1244.         } else if (realDriverClassName.equals(JdbcConstants.ORACLE_DRIVER)
  1245.                 || realDriverClassName.equals(JdbcConstants.ORACLE_DRIVER2)) {
  1246.             this.validConnectionChecker = new OracleValidConnectionChecker();
  1247.  
  1248.         } else if (realDriverClassName.equals(JdbcConstants.SQL_SERVER_DRIVER)
  1249.                    || realDriverClassName.equals(JdbcConstants.SQL_SERVER_DRIVER_SQLJDBC4)
  1250.                    || realDriverClassName.equals(JdbcConstants.SQL_SERVER_DRIVER_JTDS)) {
  1251.             this.validConnectionChecker = new MSSQLValidConnectionChecker();
  1252.  
  1253.         } else if (realDriverClassName.equals(JdbcConstants.POSTGRESQL_DRIVER)
  1254.                 || realDriverClassName.equals(JdbcConstants.ENTERPRISEDB_DRIVER)) {
  1255.             this.validConnectionChecker = new PGValidConnectionChecker();
  1256.         }
  1257.     }
  1258.  
  1259.     private void initExceptionSorter() {
  1260.         if (exceptionSorter instanceof NullExceptionSorter) {
  1261.             if (driver instanceof MockDriver) {
  1262.                 return;
  1263.             }
  1264.         } else if (this.exceptionSorter != null) {
  1265.             return;
  1266.         }
  1267.  
  1268.  
  1269.         for (Class<?> driverClass = driver.getClass();;) {
  1270.             String realDriverClassName = driverClass.getName();
  1271.             if (realDriverClassName.equals(JdbcConstants.MYSQL_DRIVER) //
  1272.                     || realDriverClassName.equals(JdbcConstants.MYSQL_DRIVER_6)) {
  1273.                 this.exceptionSorter = new MySqlExceptionSorter();
  1274.                 this.isMySql = true;
  1275.             } else if (realDriverClassName.equals(JdbcConstants.ORACLE_DRIVER)
  1276.                     || realDriverClassName.equals(JdbcConstants.ORACLE_DRIVER2)) {
  1277.                 this.exceptionSorter = new OracleExceptionSorter();
  1278.             } else if (realDriverClassName.equals("com.informix.jdbc.IfxDriver")) {
  1279.                 this.exceptionSorter = new InformixExceptionSorter();
  1280.  
  1281.             } else if (realDriverClassName.equals("com.sybase.jdbc2.jdbc.SybDriver")) {
  1282.                 this.exceptionSorter = new SybaseExceptionSorter();
  1283.  
  1284.             } else if (realDriverClassName.equals(JdbcConstants.POSTGRESQL_DRIVER)
  1285.                     || realDriverClassName.equals(JdbcConstants.ENTERPRISEDB_DRIVER)) {
  1286.                 this.exceptionSorter = new PGExceptionSorter();
  1287.  
  1288.             } else if (realDriverClassName.equals("com.alibaba.druid.mock.MockDriver")) {
  1289.                 this.exceptionSorter = new MockExceptionSorter();
  1290.             } else if (realDriverClassName.contains("DB2")) {
  1291.                 this.exceptionSorter = new DB2ExceptionSorter();
  1292.  
  1293.             } else {
  1294.                 Class<?> superClass = driverClass.getSuperclass();
  1295.                 if (superClass != null && superClass != Object.class) {
  1296.                     driverClass = superClass;
  1297.                     continue;
  1298.                 }
  1299.             }
  1300.  
  1301.             break;
  1302.         }
  1303.     }
  1304.  
  1305.     @Override
  1306.     public DruidPooledConnection getConnection() throws SQLException {
  1307.         return getConnection(maxWait);
  1308.     }
  1309.  
  1310.     public DruidPooledConnection getConnection(long maxWaitMillis) throws SQLException {
  1311.         init();
  1312.  
  1313.         if (filters.size() > 0) {
  1314.             FilterChainImpl filterChain = new FilterChainImpl(this);
  1315.             return filterChain.dataSource_connect(this, maxWaitMillis);
  1316.         } else {
  1317.             return getConnectionDirect(maxWaitMillis);
  1318.         }
  1319.     }
  1320.  
  1321.     @Override
  1322.     public PooledConnection getPooledConnection() throws SQLException {
  1323.         return getConnection(maxWait);
  1324.     }
  1325.  
  1326.     @Override
  1327.     public PooledConnection getPooledConnection(String user, String password) throws SQLException {
  1328.         throw new UnsupportedOperationException("Not supported by DruidDataSource");
  1329.     }
  1330.  
  1331.     public DruidPooledConnection getConnectionDirect(long maxWaitMillis) throws SQLException {
  1332.         int notFullTimeoutRetryCnt = 0;
  1333.         for (;;) {
  1334.             // handle notFullTimeoutRetry
  1335.             DruidPooledConnection poolableConnection;
  1336.             try {
  1337.                 poolableConnection = getConnectionInternal(maxWaitMillis);
  1338.             } catch (GetConnectionTimeoutException ex) {
  1339.                 if (notFullTimeoutRetryCnt <= this.notFullTimeoutRetryCount && !isFull()) {
  1340.                     notFullTimeoutRetryCnt++;
  1341.                     if (LOG.isWarnEnabled()) {
  1342.                         LOG.warn("get connection timeout retry : " + notFullTimeoutRetryCnt);
  1343.                     }
  1344.                     continue;
  1345.                 }
  1346.                 throw ex;
  1347.             }
  1348.  
  1349.             if (testOnBorrow) {
  1350.                 boolean validate = testConnectionInternal(poolableConnection.holder, poolableConnection.conn);
  1351.                 if (!validate) {
  1352.                     if (LOG.isDebugEnabled()) {
  1353.                         LOG.debug("skip not validate connection.");
  1354.                     }
  1355.  
  1356.                     Connection realConnection = poolableConnection.conn;
  1357.                     discardConnection(realConnection);
  1358.                     continue;
  1359.                 }
  1360.             } else {
  1361.                 Connection realConnection = poolableConnection.conn;
  1362.                 if (poolableConnection.conn.isClosed()) {
  1363.                     discardConnection(null); // 传入null，避免重复关闭
  1364.                     continue;
  1365.                 }
  1366.  
  1367.                 if (testWhileIdle) {
  1368.                     final DruidConnectionHolder holder = poolableConnection.holder;
  1369.                     long currentTimeMillis             = System.currentTimeMillis();
  1370.                     long lastActiveTimeMillis          = holder.lastActiveTimeMillis;
  1371.                     long lastKeepTimeMillis            = holder.lastKeepTimeMillis;
  1372.  
  1373.                     if (lastKeepTimeMillis > lastActiveTimeMillis) {
  1374.                         lastActiveTimeMillis = lastKeepTimeMillis;
  1375.                     }
  1376.  
  1377.                     long idleMillis                    = currentTimeMillis - lastActiveTimeMillis;
  1378.  
  1379.                     long timeBetweenEvictionRunsMillis = this.timeBetweenEvictionRunsMillis;
  1380.  
  1381.                     if (timeBetweenEvictionRunsMillis <= 0) {
  1382.                         timeBetweenEvictionRunsMillis = DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
  1383.                     }
  1384.  
  1385.                     if (idleMillis >= timeBetweenEvictionRunsMillis
  1386.                             || idleMillis < 0 // unexcepted branch
  1387.                             ) {
  1388.                         boolean validate = testConnectionInternal(poolableConnection.holder, poolableConnection.conn);
  1389.                         if (!validate) {
  1390.                             if (LOG.isDebugEnabled()) {
  1391.                                 LOG.debug("skip not validate connection.");
  1392.                             }
  1393.  
  1394.                             discardConnection(realConnection);
  1395.                              continue;
  1396.                         }
  1397.                     }
  1398.                 }
  1399.             }
  1400.  
  1401.             if (removeAbandoned) {
  1402.                 StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
  1403.                 poolableConnection.connectStackTrace = stackTrace;
  1404.                 poolableConnection.setConnectedTimeNano();
  1405.                 poolableConnection.traceEnable = true;
  1406.  
  1407.                 activeConnectionLock.lock();
  1408.                 try {
  1409.                     activeConnections.put(poolableConnection, PRESENT);
  1410.                 } finally {
  1411.                     activeConnectionLock.unlock();
  1412.                 }
  1413.             }
  1414.  
  1415.             if (!this.defaultAutoCommit) {
  1416.                 poolableConnection.setAutoCommit(false);
  1417.             }
  1418.  
  1419.             return poolableConnection;
  1420.         }
  1421.     }
  1422.  
  1423.     /**
  1424.      * 抛弃连接，不进行回收，而是抛弃
  1425.      * 
  1426.      * @param realConnection
  1427.      */
  1428.     public void discardConnection(Connection realConnection) {
  1429.         JdbcUtils.close(realConnection);
  1430.  
  1431.         lock.lock();
  1432.         try {
  1433.             activeCount--;
  1434.             discardCount++;
  1435.  
  1436.             if (activeCount <= minIdle) {
  1437.                 emptySignal();
  1438.             }
  1439.         } finally {
  1440.             lock.unlock();
  1441.         }
  1442.     }
  1443.  
  1444.     private DruidPooledConnection getConnectionInternal(long maxWait) throws SQLException {
  1445.         if (closed) {
  1446.             connectErrorCountUpdater.incrementAndGet(this);
  1447.             throw new DataSourceClosedException("dataSource already closed at " + new Date(closeTimeMillis));
  1448.         }
  1449.  
  1450.         if (!enable) {
  1451.             connectErrorCountUpdater.incrementAndGet(this);
  1452.             throw new DataSourceDisableException();
  1453.         }
  1454.  
  1455.         final long nanos = TimeUnit.MILLISECONDS.toNanos(maxWait);
  1456.         final int maxWaitThreadCount = this.maxWaitThreadCount;
  1457.  
  1458.         DruidConnectionHolder holder;
  1459.  
  1460.         for (boolean createDirect = false;;) {
  1461.             if (createDirect) {
  1462.                 createStartNanosUpdater.set(this, System.nanoTime());
  1463.                 if (creatingCountUpdater.compareAndSet(this, 0, 1)) {
  1464.                     PhysicalConnectionInfo pyConnInfo = DruidDataSource.this.createPhysicalConnection();
  1465.                     holder = new DruidConnectionHolder(this, pyConnInfo);
  1466.                     holder.lastActiveTimeMillis = System.currentTimeMillis();
  1467.  
  1468.                     creatingCountUpdater.decrementAndGet(this);
  1469.                     directCreateCountUpdater.incrementAndGet(this);
  1470.  
  1471.                     if (LOG.isDebugEnabled()) {
  1472.                         LOG.debug("conn-direct_create ");
  1473.                     }
  1474.  
  1475.                     boolean discard = false;
  1476.                     lock.lock();
  1477.                     try {
  1478.                         if (activeCount < maxActive) {
  1479.                             activeCount++;
  1480.                             if (activeCount > activePeak) {
  1481.                                 activePeak = activeCount;
  1482.                                 activePeakTime = System.currentTimeMillis();
  1483.                             }
  1484.                             break;
  1485.                         } else {
  1486.                             discard = true;
  1487.                         }
  1488.                     } finally {
  1489.                         lock.unlock();
  1490.                     }
  1491.  
  1492.                     if (discard) {
  1493.                         JdbcUtils.close(pyConnInfo.getPhysicalConnection());
  1494.                     }
  1495.                 }
  1496.             }
  1497.  
  1498.             try {
  1499.                 lock.lockInterruptibly();
  1500.             } catch (InterruptedException e) {
  1501.                 connectErrorCountUpdater.incrementAndGet(this);
  1502.                 throw new SQLException("interrupt", e);
  1503.             }
  1504.  
  1505.             try {
  1506.                 if (maxWaitThreadCount > 0
  1507.                         && notEmptyWaitThreadCount >= maxWaitThreadCount) {
  1508.                     connectErrorCountUpdater.incrementAndGet(this);
  1509.                     throw new SQLException("maxWaitThreadCount " + maxWaitThreadCount + ", current wait Thread count "
  1510.                             + lock.getQueueLength());
  1511.                 }
  1512.  
  1513.                 if (onFatalError
  1514.                         && onFatalErrorMaxActive > 0
  1515.                         && activeCount >= onFatalErrorMaxActive) {
  1516.                     connectErrorCountUpdater.incrementAndGet(this);
  1517.  
  1518.                     StringBuilder errorMsg = new StringBuilder();
  1519.                     errorMsg.append("onFatalError, activeCount ")
  1520.                             .append(activeCount)
  1521.                             .append(", onFatalErrorMaxActive ")
  1522.                             .append(onFatalErrorMaxActive);
  1523.  
  1524.                     if (lastFatalErrorTimeMillis > 0) {
  1525.                         errorMsg.append(", time '")
  1526.                                 .append(StringUtils.formatDateTime19(
  1527.                                         lastFatalErrorTimeMillis, TimeZone.getDefault()))
  1528.                                 .append("'");
  1529.                     }
  1530.  
  1531.                     if (lastFatalErrorSql != null) {
  1532.                         errorMsg.append(", sql \n")
  1533.                                 .append(lastFatalErrorSql);
  1534.                     }
  1535.  
  1536.                     throw new SQLException(
  1537.                             errorMsg.toString(), lastFatalError);
  1538.                 }
  1539.  
  1540.                 connectCount++;
  1541.  
  1542.                 if (createScheduler != null
  1543.                         && poolingCount == 0
  1544.                         && activeCount < maxActive
  1545.                         && creatingCountUpdater.get(this) == 0
  1546.                         && createScheduler instanceof ScheduledThreadPoolExecutor) {
  1547.                     ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) createScheduler;
  1548.                     if (executor.getQueue().size() > 0) {
  1549.                         createDirect = true;
  1550.                         continue;
  1551.                     }
  1552.                 }
  1553.  
  1554.                 if (maxWait > 0) {
  1555.                     holder = pollLast(nanos);
  1556.                 } else {
  1557.                     holder = takeLast();
  1558.                 }
  1559.  
  1560.                 if (holder != null) {
  1561.                     activeCount++;
  1562.                     if (activeCount > activePeak) {
  1563.                         activePeak = activeCount;
  1564.                         activePeakTime = System.currentTimeMillis();
  1565.                     }
  1566.                 }
  1567.             } catch (InterruptedException e) {
  1568.                 connectErrorCountUpdater.incrementAndGet(this);
  1569.                 throw new SQLException(e.getMessage(), e);
  1570.             } catch (SQLException e) {
  1571.                 connectErrorCountUpdater.incrementAndGet(this);
  1572.                 throw e;
  1573.             } finally {
  1574.                 lock.unlock();
  1575.             }
  1576.  
  1577.             break;
  1578.         }
  1579.  
  1580.         if (holder == null) {
  1581.             long waitNanos = waitNanosLocal.get();
  1582.  
  1583.             StringBuilder buf = new StringBuilder(128);
  1584.             buf.append("wait millis ")//
  1585.                .append(waitNanos / (1000 * 1000))//
  1586.                .append(", active ").append(activeCount)//
  1587.                .append(", maxActive ").append(maxActive)//
  1588.                .append(", creating ").append(creatingCount)//
  1589.             ;
  1590.             if (creatingCount > 0 && createStartNanos > 0) {
  1591.                 long createElapseMillis = (System.nanoTime() - createStartNanos) / (1000 * 1000);
  1592.                 if (createElapseMillis > 0) {
  1593.                     buf.append(", createElapseMillis ").append(createElapseMillis);
  1594.                 }
  1595.             }
  1596.  
  1597.             if (createErrorCount > 0) {
  1598.                 buf.append(", createErrorCount ").append(createErrorCount);
  1599.             }
  1600.  
  1601.             List<JdbcSqlStatValue> sqlList = this.getDataSourceStat().getRuningSqlList();
  1602.             for (int i = 0; i < sqlList.size(); ++i) {
  1603.                 if (i != 0) {
  1604.                     buf.append('\n');
  1605.                 } else {
  1606.                     buf.append(", ");
  1607.                 }
  1608.                 JdbcSqlStatValue sql = sqlList.get(i);
  1609.                 buf.append("runningSqlCount ").append(sql.getRunningCount());
  1610.                 buf.append(" : ");
  1611.                 buf.append(sql.getSql());
  1612.             }
  1613.  
  1614.             String errorMessage = buf.toString();
  1615.  
  1616.             if (this.createError != null) {
  1617.                 throw new GetConnectionTimeoutException(errorMessage, createError);
  1618.             } else {
  1619.                 throw new GetConnectionTimeoutException(errorMessage);
  1620.             }
  1621.         }
  1622.  
  1623.         holder.incrementUseCount();
  1624.  
  1625.         DruidPooledConnection poolalbeConnection = new DruidPooledConnection(holder);
  1626.         return poolalbeConnection;
  1627.     }
  1628.  
  1629.     public void handleConnectionException(DruidPooledConnection pooledConnection, Throwable t, String sql) throws SQLException {
  1630.         final DruidConnectionHolder holder = pooledConnection.getConnectionHolder();
  1631.  
  1632.         errorCountUpdater.incrementAndGet(this);
  1633.         lastError = t;
  1634.         lastErrorTimeMillis = System.currentTimeMillis();
  1635.  
  1636.         if (t instanceof SQLException) {
  1637.             SQLException sqlEx = (SQLException) t;
  1638.  
  1639.             // broadcastConnectionError
  1640.             ConnectionEvent event = new ConnectionEvent(pooledConnection, sqlEx);
  1641.             for (ConnectionEventListener eventListener : holder.getConnectionEventListeners()) {
  1642.                 eventListener.connectionErrorOccurred(event);
  1643.             }
  1644.  
  1645.             // exceptionSorter.isExceptionFatal
  1646.             if (exceptionSorter != null && exceptionSorter.isExceptionFatal(sqlEx)) {
  1647.                 handleFatalError(pooledConnection, sqlEx, sql);
  1648.             }
  1649.  
  1650.             throw sqlEx;
  1651.         } else {
  1652.             throw new SQLException("Error", t);
  1653.         }
  1654.     }
  1655.  
  1656.     protected final void handleFatalError(DruidPooledConnection conn, SQLException error, String sql) throws SQLException {
  1657.         final DruidConnectionHolder holder = conn.holder;
  1658.  
  1659.         if (conn.isTraceEnable()) {
  1660.             activeConnectionLock.lock();
  1661.             try {
  1662.                 if (conn.isTraceEnable()) {
  1663.                     activeConnections.remove(conn);
  1664.                     conn.setTraceEnable(false);
  1665.                 }
  1666.             } finally {
  1667.                 activeConnectionLock.unlock();
  1668.             }
  1669.         }
  1670.  
  1671.         long lastErrorTimeMillis = this.lastErrorTimeMillis;
  1672.         if (lastErrorTimeMillis == 0) {
  1673.             lastErrorTimeMillis = System.currentTimeMillis();
  1674.         }
  1675.  
  1676.         if (sql != null && sql.length() > 1024) {
  1677.             sql = sql.substring(0, 1024);
  1678.         }
  1679.  
  1680.         boolean requireDiscard = false;
  1681.         final ReentrantLock lock = conn.lock;
  1682.         lock.lock();
  1683.         try {
  1684.             if ((!conn.isClosed()) || !conn.isDisable()) {
  1685.                 holder.setDiscard(true);
  1686.                 conn.disable(error);
  1687.                 requireDiscard = true;
  1688.             }
  1689.  
  1690.             lastFatalErrorTimeMillis = lastErrorTimeMillis;
  1691.             onFatalError = true;
  1692.             lastFatalError = error;
  1693.             lastFatalErrorSql = sql;
  1694.         } finally {
  1695.             lock.unlock();
  1696.         }
  1697.  
  1698.         if (requireDiscard) {
  1699.             if (holder.statementTrace != null) {
  1700.                 holder.lock.lock();
  1701.                 try {
  1702.                     for (Statement stmt : holder.statementTrace) {
  1703.                         JdbcUtils.close(stmt);
  1704.                     }
  1705.                 } finally {
  1706.                     holder.lock.unlock();
  1707.                 }
  1708.             }
  1709.  
  1710.             this.discardConnection(holder.getConnection());
  1711.             holder.setDiscard(true);
  1712.         }
  1713.  
  1714.         LOG.error("discard connection", error);
  1715.     }
  1716.  
  1717.     /**
  1718.      * 回收连接
  1719.      */
  1720.     protected void recycle(DruidPooledConnection pooledConnection) throws SQLException {
  1721.         final DruidConnectionHolder holder = pooledConnection.holder;
  1722.  
  1723.         if (holder == null) {
  1724.             LOG.warn("connectionHolder is null");
  1725.             return;
  1726.         }
  1727.  
  1728.         if (logDifferentThread //
  1729.             && (!isAsyncCloseConnectionEnable()) //
  1730.             && pooledConnection.ownerThread != Thread.currentThread()//
  1731.         ) {
  1732.             LOG.warn("get/close not same thread");
  1733.         }
  1734.  
  1735.         final Connection physicalConnection = holder.conn;
  1736.  
  1737.         if (pooledConnection.traceEnable) {
  1738.             Object oldInfo = null;
  1739.             activeConnectionLock.lock();
  1740.             try {
  1741.                 if (pooledConnection.traceEnable) {
  1742.                     oldInfo = activeConnections.remove(pooledConnection);
  1743.                     pooledConnection.traceEnable = false;
  1744.                 }
  1745.             } finally {
  1746.                 activeConnectionLock.unlock();
  1747.             }
  1748.             if (oldInfo == null) {
  1749.                 if (LOG.isWarnEnabled()) {
  1750.                     LOG.warn("remove abandonded failed. activeConnections.size " + activeConnections.size());
  1751.                 }
  1752.             }
  1753.         }
  1754.  
  1755.         final boolean isAutoCommit = holder.underlyingAutoCommit;
  1756.         final boolean isReadOnly = holder.underlyingReadOnly;
  1757.         final boolean testOnReturn = this.testOnReturn;
  1758.  
  1759.         try {
  1760.             // check need to rollback?
  1761.             if ((!isAutoCommit) && (!isReadOnly)) {
  1762.                 pooledConnection.rollback();
  1763.             }
  1764.  
  1765.             // reset holder, restore default settings, clear warnings
  1766.             boolean isSameThread = pooledConnection.ownerThread == Thread.currentThread();
  1767.             if (!isSameThread) {
  1768.                 final ReentrantLock lock = pooledConnection.lock;
  1769.                 lock.lock();
  1770.                 try {
  1771.                     holder.reset();
  1772.                 } finally {
  1773.                     lock.unlock();
  1774.                 }
  1775.             } else {
  1776.                 holder.reset();
  1777.             }
  1778.  
  1779.             if (holder.discard) {
  1780.                 return;
  1781.             }
  1782.  
  1783.             if (phyMaxUseCount > 0 && holder.useCount >= phyMaxUseCount) {
  1784.                 discardConnection(holder.conn);
  1785.                 return;
  1786.             }
  1787.  
  1788.             if (physicalConnection.isClosed()) {
  1789.                 lock.lock();
  1790.                 try {
  1791.                     activeCount--;
  1792.                     closeCount++;
  1793.                 } finally {
  1794.                     lock.unlock();
  1795.                 }
  1796.                 return;
  1797.             }
  1798.  
  1799.             if (testOnReturn) {
  1800.                 boolean validate = testConnectionInternal(holder, physicalConnection);
  1801.                 if (!validate) {
  1802.                     JdbcUtils.close(physicalConnection);
  1803.  
  1804.                     destroyCountUpdater.incrementAndGet(this);
  1805.  
  1806.                     lock.lock();
  1807.                     try {
  1808.                         activeCount--;
  1809.                         closeCount++;
  1810.                     } finally {
  1811.                         lock.unlock();
  1812.                     }
  1813.                     return;
  1814.                 }
  1815.             }
  1816.  
  1817.             if (!enable) {
  1818.                 discardConnection(holder.conn);
  1819.                 return;
  1820.             }
  1821.  
  1822.             boolean result;
  1823.             final long currentTimeMillis = System.currentTimeMillis();
  1824.  
  1825.             if (phyTimeoutMillis > 0) {
  1826.                 long phyConnectTimeMillis = currentTimeMillis - holder.connectTimeMillis;
  1827.                 if (phyConnectTimeMillis > phyTimeoutMillis) {
  1828.                     discardConnection(holder.conn);
  1829.                     return;
  1830.                 }
  1831.             }
  1832.  
  1833.             lock.lock();
  1834.             try {
  1835.                 activeCount--;
  1836.                 closeCount++;
  1837.  
  1838.                 result = putLast(holder, currentTimeMillis);
  1839.                 recycleCount++;
  1840.             } finally {
  1841.                 lock.unlock();
  1842.             }
  1843.  
  1844.             if (!result) {
  1845.                 JdbcUtils.close(holder.conn);
  1846.                 LOG.info("connection recyle failed.");
  1847.             }
  1848.         } catch (Throwable e) {
  1849.             holder.clearStatementCache();
  1850.  
  1851.             if (!holder.discard) {
  1852.                 this.discardConnection(physicalConnection);
  1853.                 holder.discard = true;
  1854.             }
  1855.  
  1856.             LOG.error("recyle error", e);
  1857.             recycleErrorCountUpdater.incrementAndGet(this);
  1858.         }
  1859.     }
  1860.  
  1861.     public long getRecycleErrorCount() {
  1862.         return recycleErrorCount;
  1863.     }
  1864.  
  1865.     public void clearStatementCache() throws SQLException {
  1866.         lock.lock();
  1867.         try {
  1868.             for (int i = 0; i < poolingCount; ++i) {
  1869.                 DruidConnectionHolder conn = connections[i];
  1870.  
  1871.                 if (conn.statementPool != null) {
  1872.                     conn.statementPool.clear();
  1873.                 }
  1874.             }
  1875.         } finally {
  1876.             lock.unlock();
  1877.         }
  1878.     }
  1879.  
  1880.     /**
  1881.      * close datasource
  1882.      */
  1883.     public void close() {
  1884.         if (LOG.isInfoEnabled()) {
  1885.             LOG.info("{dataSource-" + this.getID() + "} closing ...");
  1886.         }
  1887.  
  1888.         lock.lock();
  1889.         try {
  1890.             if (this.closed) {
  1891.                 return;
  1892.             }
  1893.  
  1894.             if (!this.inited) {
  1895.                 return;
  1896.             }
  1897.  
  1898.             this.closing = true;
  1899.  
  1900.             if (logStatsThread != null) {
  1901.                 logStatsThread.interrupt();
  1902.             }
  1903.  
  1904.             if (createConnectionThread != null) {
  1905.                 createConnectionThread.interrupt();
  1906.             }
  1907.  
  1908.             if (destroyConnectionThread != null) {
  1909.                 destroyConnectionThread.interrupt();
  1910.             }
  1911.  
  1912.             if (createSchedulerFuture != null) {
  1913.                 createSchedulerFuture.cancel(true);
  1914.             }
  1915.  
  1916.             if (destroySchedulerFuture != null) {
  1917.                 destroySchedulerFuture.cancel(true);
  1918.             }
  1919.  
  1920.             for (int i = 0; i < poolingCount; ++i) {
  1921.                 DruidConnectionHolder connHolder = connections[i];
  1922.  
  1923.                 for (PreparedStatementHolder stmtHolder : connHolder.getStatementPool().getMap().values()) {
  1924.                     connHolder.getStatementPool().closeRemovedStatement(stmtHolder);
  1925.                 }
  1926.                 connHolder.getStatementPool().getMap().clear();
  1927.  
  1928.                 Connection physicalConnection = connHolder.getConnection();
  1929.                 try {
  1930.                     physicalConnection.close();
  1931.                 } catch (Exception ex) {
  1932.                     LOG.warn("close connection error", ex);
  1933.                 }
  1934.                 connections[i] = null;
  1935.                 destroyCountUpdater.incrementAndGet(this);
  1936.             }
  1937.             poolingCount = 0;
  1938.             unregisterMbean();
  1939.  
  1940.             enable = false;
  1941.             notEmpty.signalAll();
  1942.             notEmptySignalCount++;
  1943.  
  1944.             this.closed = true;
  1945.             this.closeTimeMillis = System.currentTimeMillis();
  1946.  
  1947.             for (Filter filter : filters) {
  1948.                 filter.destroy();
  1949.             }
  1950.         } finally {
  1951.             lock.unlock();
  1952.         }
  1953.  
  1954.         if (LOG.isInfoEnabled()) {
  1955.             LOG.info("{dataSource-" + this.getID() + "} closed");
  1956.         }
  1957.     }
  1958.  
  1959.     public void registerMbean() {
  1960.         if (!mbeanRegistered) {
  1961.             AccessController.doPrivileged(new PrivilegedAction<Object>() {
  1962.  
  1963.                 @Override
  1964.                 public Object run() {
  1965.                     ObjectName objectName = DruidDataSourceStatManager.addDataSource(DruidDataSource.this,
  1966.                                                                                      DruidDataSource.this.name);
  1967.  
  1968.                     DruidDataSource.this.setObjectName(objectName);
  1969.                     DruidDataSource.this.mbeanRegistered = true;
  1970.  
  1971.                     return null;
  1972.                 }
  1973.             });
  1974.         }
  1975.     }
  1976.  
  1977.     public void unregisterMbean() {
  1978.         if (mbeanRegistered) {
  1979.             AccessController.doPrivileged(new PrivilegedAction<Object>() {
  1980.  
  1981.                 @Override
  1982.                 public Object run() {
  1983.                     DruidDataSourceStatManager.removeDataSource(DruidDataSource.this);
  1984.                     DruidDataSource.this.mbeanRegistered = false;
  1985.                     return null;
  1986.                 }
  1987.             });
  1988.         }
  1989.     }
  1990.  
  1991.     public boolean isMbeanRegistered() {
  1992.         return mbeanRegistered;
  1993.     }
  1994.  
  1995.     boolean putLast(DruidConnectionHolder e, long lastActiveTimeMillis) {
  1996.         if (poolingCount >= maxActive) {
  1997.             return false;
  1998.         }
  1999.  
  2000.         e.lastActiveTimeMillis = lastActiveTimeMillis;
  2001.         connections[poolingCount] = e;
  2002.         incrementPoolingCount();
  2003.  
  2004.         if (poolingCount > poolingPeak) {
  2005.             poolingPeak = poolingCount;
  2006.             poolingPeakTime = lastActiveTimeMillis;
  2007.         }
  2008.  
  2009.         notEmpty.signal();
  2010.         notEmptySignalCount++;
  2011.  
  2012.         return true;
  2013.     }
  2014.  
  2015.     DruidConnectionHolder takeLast() throws InterruptedException, SQLException {
  2016.         try {
  2017.             while (poolingCount == 0) {
  2018.                 emptySignal(); // send signal to CreateThread create connection
  2019.  
  2020.                 if (failFast && isFailContinuous()) {
  2021.                     throw new DataSourceNotAvailableException(createError);
  2022.                 }
  2023.  
  2024.                 notEmptyWaitThreadCount++;
  2025.                 if (notEmptyWaitThreadCount > notEmptyWaitThreadPeak) {
  2026.                     notEmptyWaitThreadPeak = notEmptyWaitThreadCount;
  2027.                 }
  2028.                 try {
  2029.                     notEmpty.await(); // signal by recycle or creator
  2030.                 } finally {
  2031.                     notEmptyWaitThreadCount--;
  2032.                 }
  2033.                 notEmptyWaitCount++;
  2034.  
  2035.                 if (!enable) {
  2036.                     connectErrorCountUpdater.incrementAndGet(this);
  2037.                     throw new DataSourceDisableException();
  2038.                 }
  2039.             }
  2040.         } catch (InterruptedException ie) {
  2041.             notEmpty.signal(); // propagate to non-interrupted thread
  2042.             notEmptySignalCount++;
  2043.             throw ie;
  2044.         }
  2045.  
  2046.         decrementPoolingCount();
  2047.         DruidConnectionHolder last = connections[poolingCount];
  2048.         connections[poolingCount] = null;
  2049.  
  2050.         return last;
  2051.     }
  2052.  
  2053.     private DruidConnectionHolder pollLast(long nanos) throws InterruptedException, SQLException {
  2054.         long estimate = nanos;
  2055.  
  2056.         for (;;) {
  2057.             if (poolingCount == 0) {
  2058.                 emptySignal(); // send signal to CreateThread create connection
  2059.  
  2060.                 if (failFast && isFailContinuous()) {
  2061.                     throw new DataSourceNotAvailableException(createError);
  2062.                 }
  2063.  
  2064.                 if (estimate <= 0) {
  2065.                     waitNanosLocal.set(nanos - estimate);
  2066.                     return null;
  2067.                 }
  2068.  
  2069.                 notEmptyWaitThreadCount++;
  2070.                 if (notEmptyWaitThreadCount > notEmptyWaitThreadPeak) {
  2071.                     notEmptyWaitThreadPeak = notEmptyWaitThreadCount;
  2072.                 }
  2073.  
  2074.                 try {
  2075.                     long startEstimate = estimate;
  2076.                     estimate = notEmpty.awaitNanos(estimate); // signal by
  2077.                                                               // recycle or
  2078.                                                               // creator
  2079.                     notEmptyWaitCount++;
  2080.                     notEmptyWaitNanos += (startEstimate - estimate);
  2081.  
  2082.                     if (!enable) {
  2083.                         connectErrorCountUpdater.incrementAndGet(this);
  2084.                         throw new DataSourceDisableException();
  2085.                     }
  2086.                 } catch (InterruptedException ie) {
  2087.                     notEmpty.signal(); // propagate to non-interrupted thread
  2088.                     notEmptySignalCount++;
  2089.                     throw ie;
  2090.                 } finally {
  2091.                     notEmptyWaitThreadCount--;
  2092.                 }
  2093.  
  2094.                 if (poolingCount == 0) {
  2095.                     if (estimate > 0) {
  2096.                         continue;
  2097.                     }
  2098.  
  2099.                     waitNanosLocal.set(nanos - estimate);
  2100.                     return null;
  2101.                 }
  2102.             }
  2103.  
  2104.             decrementPoolingCount();
  2105.             DruidConnectionHolder last = connections[poolingCount];
  2106.             connections[poolingCount] = null;
  2107.  
  2108.             long waitNanos = nanos - estimate;
  2109.             last.setLastNotEmptyWaitNanos(waitNanos);
  2110.  
  2111.             return last;
  2112.         }
  2113.     }
  2114.  
  2115.     private final void decrementPoolingCount() {
  2116.         poolingCount--;
  2117.     }
  2118.  
  2119.     private final void incrementPoolingCount() {
  2120.         poolingCount++;
  2121.     }
  2122.  
  2123.     @Override
  2124.     public Connection getConnection(String username, String password) throws SQLException {
  2125.         if (this.username == null
  2126.                 && this.password == null
  2127.                 && username != null
  2128.                 && password != null) {
  2129.             this.username = username;
  2130.             this.password = password;
  2131.  
  2132.             return getConnection();
  2133.         }
  2134.  
  2135.         if (!StringUtils.equals(username, this.username)) {
  2136.             throw new UnsupportedOperationException("Not supported by DruidDataSource");
  2137.         }
  2138.  
  2139.         if (!StringUtils.equals(password, this.password)) {
  2140.             throw new UnsupportedOperationException("Not supported by DruidDataSource");
  2141.         }
  2142.  
  2143.         return getConnection();
  2144.     }
  2145.  
  2146.     public long getCreateCount() {
  2147.         return createCount;
  2148.     }
  2149.  
  2150.     public long getDestroyCount() {
  2151.         return destroyCount;
  2152.     }
  2153.  
  2154.     public long getConnectCount() {
  2155.         lock.lock();
  2156.         try {
  2157.             return connectCount;
  2158.         } finally {
  2159.             lock.unlock();
  2160.         }
  2161.     }
  2162.  
  2163.     public long getCloseCount() {
  2164.         return closeCount;
  2165.     }
  2166.  
  2167.     public long getConnectErrorCount() {
  2168.         return connectErrorCountUpdater.get(this);
  2169.     }
  2170.  
  2171.     @Override
  2172.     public int getPoolingCount() {
  2173.         lock.lock();
  2174.         try {
  2175.             return poolingCount;
  2176.         } finally {
  2177.             lock.unlock();
  2178.         }
  2179.     }
  2180.  
  2181.     public int getPoolingPeak() {
  2182.         lock.lock();
  2183.         try {
  2184.             return poolingPeak;
  2185.         } finally {
  2186.             lock.unlock();
  2187.         }
  2188.     }
  2189.  
  2190.     public Date getPoolingPeakTime() {
  2191.         if (poolingPeakTime <= 0) {
  2192.             return null;
  2193.         }
  2194.  
  2195.         return new Date(poolingPeakTime);
  2196.     }
  2197.  
  2198.     public long getRecycleCount() {
  2199.         return recycleCount;
  2200.     }
  2201.  
  2202.     public int getActiveCount() {
  2203.         lock.lock();
  2204.         try {
  2205.             return activeCount;
  2206.         } finally {
  2207.             lock.unlock();
  2208.         }
  2209.     }
  2210.  
  2211.     public void logStats() {
  2212.         final DruidDataSourceStatLogger statLogger = this.statLogger;
  2213.         if (statLogger == null) {
  2214.             return;
  2215.         }
  2216.  
  2217.         DruidDataSourceStatValue statValue = getStatValueAndReset();
  2218.  
  2219.         statLogger.log(statValue);
  2220.     }
  2221.  
  2222.     public DruidDataSourceStatValue getStatValueAndReset() {
  2223.         DruidDataSourceStatValue value = new DruidDataSourceStatValue();
  2224.  
  2225.         lock.lock();
  2226.         try {
  2227.             value.setPoolingCount(this.poolingCount);
  2228.             value.setPoolingPeak(this.poolingPeak);
  2229.             value.setPoolingPeakTime(this.poolingPeakTime);
  2230.  
  2231.             value.setActiveCount(this.activeCount);
  2232.             value.setActivePeak(this.activePeak);
  2233.             value.setActivePeakTime(this.activePeakTime);
  2234.  
  2235.             value.setConnectCount(this.connectCount);
  2236.             value.setCloseCount(this.closeCount);
  2237.             value.setWaitThreadCount(lock.getWaitQueueLength(notEmpty));
  2238.             value.setNotEmptyWaitCount(this.notEmptyWaitCount);
  2239.             value.setNotEmptyWaitNanos(this.notEmptyWaitNanos);
  2240.             value.setKeepAliveCheckCount(this.keepAliveCheckCount);
  2241.  
  2242.             // reset
  2243.             this.poolingPeak = 0;
  2244.             this.poolingPeakTime = 0;
  2245.             this.activePeak = 0;
  2246.             this.activePeakTime = 0;
  2247.             this.connectCount = 0;
  2248.             this.closeCount = 0;
  2249.             this.keepAliveCheckCount = 0;
  2250.  
  2251.             this.notEmptyWaitCount = 0;
  2252.             this.notEmptyWaitNanos = 0;
  2253.         } finally {
  2254.             lock.unlock();
  2255.         }
  2256.  
  2257.         value.setName(this.getName());
  2258.         value.setDbType(this.dbType);
  2259.         value.setDriverClassName(this.getDriverClassName());
  2260.  
  2261.         value.setUrl(this.getUrl());
  2262.         value.setUserName(this.getUsername());
  2263.         value.setFilterClassNames(this.getFilterClassNames());
  2264.  
  2265.         value.setInitialSize(this.getInitialSize());
  2266.         value.setMinIdle(this.getMinIdle());
  2267.         value.setMaxActive(this.getMaxActive());
  2268.  
  2269.         value.setQueryTimeout(this.getQueryTimeout());
  2270.         value.setTransactionQueryTimeout(this.getTransactionQueryTimeout());
  2271.         value.setLoginTimeout(this.getLoginTimeout());
  2272.         value.setValidConnectionCheckerClassName(this.getValidConnectionCheckerClassName());
  2273.         value.setExceptionSorterClassName(this.getExceptionSorterClassName());
  2274.  
  2275.         value.setTestOnBorrow(this.testOnBorrow);
  2276.         value.setTestOnReturn(this.testOnReturn);
  2277.         value.setTestWhileIdle(this.testWhileIdle);
  2278.  
  2279.         value.setDefaultAutoCommit(this.isDefaultAutoCommit());
  2280.  
  2281.         if (defaultReadOnly != null) {
  2282.             value.setDefaultReadOnly(defaultReadOnly);
  2283.         }
  2284.         value.setDefaultTransactionIsolation(this.getDefaultTransactionIsolation());
  2285.  
  2286.         value.setLogicConnectErrorCount(connectErrorCountUpdater.getAndSet(this, 0));
  2287.  
  2288.         value.setPhysicalConnectCount(createCountUpdater.getAndSet(this, 0));
  2289.         value.setPhysicalCloseCount(destroyCountUpdater.getAndSet(this, 0));
  2290.         value.setPhysicalConnectErrorCount(createErrorCountUpdater.getAndSet(this, 0));
  2291.  
  2292.         value.setExecuteCount(this.getAndResetExecuteCount());
  2293.         value.setErrorCount(errorCountUpdater.getAndSet(this, 0));
  2294.         value.setCommitCount(commitCountUpdater.getAndSet(this, 0));
  2295.         value.setRollbackCount(rollbackCountUpdater.getAndSet(this, 0));
  2296.  
  2297.         value.setPstmtCacheHitCount(cachedPreparedStatementHitCountUpdater.getAndSet(this,0));
  2298.         value.setPstmtCacheMissCount(cachedPreparedStatementMissCountUpdater.getAndSet(this, 0));
  2299.  
  2300.         value.setStartTransactionCount(startTransactionCountUpdater.getAndSet(this, 0));
  2301.         value.setTransactionHistogram(this.getTransactionHistogram().toArrayAndReset());
  2302.  
  2303.         value.setConnectionHoldTimeHistogram(this.getDataSourceStat().getConnectionHoldHistogram().toArrayAndReset());
  2304.         value.setRemoveAbandoned(this.isRemoveAbandoned());
  2305.         value.setClobOpenCount(this.getDataSourceStat().getClobOpenCountAndReset());
  2306.         value.setBlobOpenCount(this.getDataSourceStat().getBlobOpenCountAndReset());
  2307.  
  2308.         value.setSqlSkipCount(this.getDataSourceStat().getSkipSqlCountAndReset());
  2309.         value.setSqlList(this.getDataSourceStat().getSqlStatMapAndReset());
  2310.  
  2311.         return value;
  2312.     }
  2313.  
  2314.     public long getRemoveAbandonedCount() {
  2315.         return removeAbandonedCount;
  2316.     }
  2317.  
  2318.     protected boolean put(PhysicalConnectionInfo physicalConnectionInfo) {
  2319.         DruidConnectionHolder holder = null;
  2320.         try {
  2321.             holder = new DruidConnectionHolder(DruidDataSource.this, physicalConnectionInfo);
  2322.         } catch (SQLException ex) {
  2323.             lock.lock();
  2324.             try {
  2325.                 if (createScheduler != null) {
  2326.                     createTaskCount--;
  2327.                 }
  2328.             } finally {
  2329.                 lock.unlock();
  2330.             }
  2331.             LOG.error("create connection holder error", ex);
  2332.             return false;
  2333.         }
  2334.  
  2335.         return put(holder);
  2336.     }
  2337.  
  2338.     private boolean put(DruidConnectionHolder holder) {
  2339.         lock.lock();
  2340.         try {
  2341.             if (poolingCount >= maxActive) {
  2342.                 return false;
  2343.             }
  2344.             connections[poolingCount] = holder;
  2345.             incrementPoolingCount();
  2346.  
  2347.             if (poolingCount > poolingPeak) {
  2348.                 poolingPeak = poolingCount;
  2349.                 poolingPeakTime = System.currentTimeMillis();
  2350.             }
  2351.  
  2352.             notEmpty.signal();
  2353.             notEmptySignalCount++;
  2354.  
  2355.             if (createScheduler != null) {
  2356.                 createTaskCount--;
  2357.  
  2358.                 if (poolingCount + createTaskCount < notEmptyWaitThreadCount //
  2359.                     && activeCount + poolingCount + createTaskCount < maxActive) {
  2360.                     emptySignal();
  2361.                 }
  2362.             }
  2363.         } finally {
  2364.             lock.unlock();
  2365.         }
  2366.         return true;
  2367.     }
  2368.  
  2369.     public class CreateConnectionTask implements Runnable {
  2370.  
  2371.         private int errorCount   = 0;
  2372.         private boolean initTask = false;
  2373.  
  2374.         public CreateConnectionTask() {
  2375.  
  2376.         }
  2377.  
  2378.         public CreateConnectionTask(boolean initTask) {
  2379.             this.initTask = initTask;
  2380.         }
  2381.  
  2382.         @Override
  2383.         public void run() {
  2384.             runInternal();
  2385.         }
  2386.  
  2387.         private void runInternal() {
  2388.             for (;;) {
  2389.  
  2390.                 // addLast
  2391.                 lock.lock();
  2392.                 try {
  2393.                     if (closed || closing) {
  2394.                         createTaskCount--;
  2395.                         return;
  2396.                     }
  2397.  
  2398.                     boolean emptyWait = true;
  2399.  
  2400.                     if (createError != null && poolingCount == 0) {
  2401.                         emptyWait = false;
  2402.                     }
  2403.  
  2404.                     if (emptyWait) {
  2405.                         // 必须存在线程等待，才创建连接
  2406.                         if (poolingCount >= notEmptyWaitThreadCount //
  2407.                                 && (!(keepAlive && activeCount + poolingCount < minIdle))
  2408.                                 && (!initTask)
  2409.                                 && !isFailContinuous()
  2410.                         ) {
  2411.                             createTaskCount--;
  2412.                             return;
  2413.                         }
  2414.  
  2415.                         // 防止创建超过maxActive数量的连接
  2416.                         if (activeCount + poolingCount >= maxActive) {
  2417.                             createTaskCount--;
  2418.                             return;
  2419.                         }
  2420.                     }
  2421.                 } finally {
  2422.                     lock.unlock();
  2423.                 }
  2424.  
  2425.                 PhysicalConnectionInfo physicalConnection = null;
  2426.  
  2427.                 try {
  2428.                     physicalConnection = createPhysicalConnection();
  2429.                 } catch (OutOfMemoryError e) {
  2430.                     LOG.error("create connection OutOfMemoryError, out memory. ", e);
  2431.  
  2432.                     errorCount++;
  2433.                     if (errorCount > connectionErrorRetryAttempts && timeBetweenConnectErrorMillis > 0) {
  2434.                         // fail over retry attempts
  2435.                         setFailContinuous(true);
  2436.                         if (failFast) {
  2437.                             lock.lock();
  2438.                             try {
  2439.                                 notEmpty.signalAll();
  2440.                             } finally {
  2441.                                 lock.unlock();
  2442.                             }
  2443.                         }
  2444.  
  2445.                         if (breakAfterAcquireFailure) {
  2446.                             lock.lock();
  2447.                             try {
  2448.                                 createTaskCount--;
  2449.                             } finally {
  2450.                                 lock.unlock();
  2451.                             }
  2452.                             return;
  2453.                         }
  2454.  
  2455.                         this.errorCount = 0; // reset errorCount
  2456.                         if (closing || closed) {
  2457.                             createTaskCount--;
  2458.                             return;
  2459.                         }
  2460.                         createSchedulerFuture = createScheduler.schedule(this, timeBetweenConnectErrorMillis, TimeUnit.MILLISECONDS);
  2461.                         return;
  2462.                     }
  2463.                 } catch (SQLException e) {
  2464.                     LOG.error("create connection SQLException, url: " + jdbcUrl, e);
  2465.  
  2466.                     errorCount++;
  2467.                     if (errorCount > connectionErrorRetryAttempts && timeBetweenConnectErrorMillis > 0) {
  2468.                         // fail over retry attempts
  2469.                         setFailContinuous(true);
  2470.                         if (failFast) {
  2471.                             lock.lock();
  2472.                             try {
  2473.                                 notEmpty.signalAll();
  2474.                             } finally {
  2475.                                 lock.unlock();
  2476.                             }
  2477.                         }
  2478.  
  2479.                         if (breakAfterAcquireFailure) {
  2480.                             lock.lock();
  2481.                             try {
  2482.                                 createTaskCount--;
  2483.                             } finally {
  2484.                                 lock.unlock();
  2485.                             }
  2486.                             return;
  2487.                         }
  2488.  
  2489.                         this.errorCount = 0; // reset errorCount
  2490.                         if (closing || closed) {
  2491.                             createTaskCount--;
  2492.                             return;
  2493.                         }
  2494.                         createSchedulerFuture = createScheduler.schedule(this, timeBetweenConnectErrorMillis, TimeUnit.MILLISECONDS);
  2495.                         return;
  2496.                     }
  2497.                 } catch (RuntimeException e) {
  2498.                     LOG.error("create connection RuntimeException", e);
  2499.                     // unknow fatal exception
  2500.                     setFailContinuous(true);
  2501.                     continue;
  2502.                 } catch (Error e) {
  2503.                     lock.lock();
  2504.                     try {
  2505.                         createTaskCount--;
  2506.                     } finally {
  2507.                         lock.unlock();
  2508.                     }
  2509.                     LOG.error("create connection Error", e);
  2510.                     // unknow fatal exception
  2511.                     setFailContinuous(true);
  2512.                     break;
  2513.                 } catch (Throwable e) {
  2514.                     LOG.error("create connection unexecpted error.", e);
  2515.                     break;
  2516.                 }
  2517.  
  2518.                 if (physicalConnection == null) {
  2519.                     continue;
  2520.                 }
  2521.  
  2522.                 boolean result = put(physicalConnection);
  2523.                 if (!result) {
  2524.                     JdbcUtils.close(physicalConnection.getPhysicalConnection());
  2525.                     LOG.info("put physical connection to pool failed.");
  2526.                 }
  2527.                 break;
  2528.             }
  2529.         }
  2530.     }
  2531.  
  2532.     public class CreateConnectionThread extends Thread {
  2533.  
  2534.         public CreateConnectionThread(String name){
  2535.             super(name);
  2536.             this.setDaemon(true);
  2537.         }
  2538.  
  2539.         public void run() {
  2540.             initedLatch.countDown();
  2541.  
  2542.             long lastDiscardCount = 0;
  2543.             int errorCount = 0;
  2544.             for (;;) {
  2545.                 // addLast
  2546.                 try {
  2547.                     lock.lockInterruptibly();
  2548.                 } catch (InterruptedException e2) {
  2549.                     break;
  2550.                 }
  2551.  
  2552.                 long discardCount = DruidDataSource.this.discardCount;
  2553.                 boolean discardChanged = discardCount - lastDiscardCount > 0;
  2554.                 lastDiscardCount = discardCount;
  2555.  
  2556.                 try {
  2557.                     boolean emptyWait = true;
  2558.  
  2559.                     if (createError != null
  2560.                             && poolingCount == 0
  2561.                             && !discardChanged) {
  2562.                         emptyWait = false;
  2563.                     }
  2564.  
  2565.                     if (emptyWait
  2566.                             && asyncInit && createCount < initialSize) {
  2567.                         emptyWait = false;
  2568.                     }
  2569.  
  2570.                     if (emptyWait) {
  2571.                         // 必须存在线程等待，才创建连接
  2572.                         if (poolingCount >= notEmptyWaitThreadCount //
  2573.                                 && (!(keepAlive && activeCount + poolingCount < minIdle))
  2574.                                 && !isFailContinuous()
  2575.                         ) {
  2576.                             empty.await();
  2577.                         }
  2578.  
  2579.                         // 防止创建超过maxActive数量的连接
  2580.                         if (activeCount + poolingCount >= maxActive) {
  2581.                             empty.await();
  2582.                             continue;
  2583.                         }
  2584.                     }
  2585.  
  2586.                 } catch (InterruptedException e) {
  2587.                     lastCreateError = e;
  2588.                     lastErrorTimeMillis = System.currentTimeMillis();
  2589.  
  2590.                     if (!closing) {
  2591.                         LOG.error("create connection Thread Interrupted, url: " + jdbcUrl, e);
  2592.                     }
  2593.                     break;
  2594.                 } finally {
  2595.                     lock.unlock();
  2596.                 }
  2597.  
  2598.                 PhysicalConnectionInfo connection = null;
  2599.  
  2600.                 try {
  2601.                     connection = createPhysicalConnection();
  2602.                 } catch (SQLException e) {
  2603.                     LOG.error("create connection SQLException, url: " + jdbcUrl + ", errorCode " + e.getErrorCode()
  2604.                               + ", state " + e.getSQLState(), e);
  2605.  
  2606.                     errorCount++;
  2607.                     if (errorCount > connectionErrorRetryAttempts && timeBetweenConnectErrorMillis > 0) {
  2608.                         // fail over retry attempts
  2609.                         setFailContinuous(true);
  2610.                         if (failFast) {
  2611.                             lock.lock();
  2612.                             try {
  2613.                                 notEmpty.signalAll();
  2614.                             } finally {
  2615.                                 lock.unlock();
  2616.                             }
  2617.                         }
  2618.  
  2619.                         if (breakAfterAcquireFailure) {
  2620.                             break;
  2621.                         }
  2622.  
  2623.                         try {
  2624.                             Thread.sleep(timeBetweenConnectErrorMillis);
  2625.                         } catch (InterruptedException interruptEx) {
  2626.                             break;
  2627.                         }
  2628.                     }
  2629.                 } catch (RuntimeException e) {
  2630.                     LOG.error("create connection RuntimeException", e);
  2631.                     setFailContinuous(true);
  2632.                     continue;
  2633.                 } catch (Error e) {
  2634.                     LOG.error("create connection Error", e);
  2635.                     setFailContinuous(true);
  2636.                     break;
  2637.                 }
  2638.  
  2639.                 if (connection == null) {
  2640.                     continue;
  2641.                 }
  2642.  
  2643.                 boolean result = put(connection);
  2644.                 if (!result) {
  2645.                     JdbcUtils.close(connection.getPhysicalConnection());
  2646.                     LOG.info("put physical connection to pool failed.");
  2647.                 }
  2648.  
  2649.                 errorCount = 0; // reset errorCount
  2650.             }
  2651.         }
  2652.     }
  2653.  
  2654.     public class DestroyConnectionThread extends Thread {
  2655.  
  2656.         public DestroyConnectionThread(String name){
  2657.             super(name);
  2658.             this.setDaemon(true);
  2659.         }
  2660.  
  2661.         public void run() {
  2662.             initedLatch.countDown();
  2663.  
  2664.             for (;;) {
  2665.                 // 从前面开始删除
  2666.                 try {
  2667.                     if (closed) {
  2668.                         break;
  2669.                     }
  2670.  
  2671.                     if (timeBetweenEvictionRunsMillis > 0) {
  2672.                         Thread.sleep(timeBetweenEvictionRunsMillis);
  2673.                     } else {
  2674.                         Thread.sleep(1000); //
  2675.                     }
  2676.  
  2677.                     if (Thread.interrupted()) {
  2678.                         break;
  2679.                     }
  2680.  
  2681.                     destroyTask.run();
  2682.                 } catch (InterruptedException e) {
  2683.                     break;
  2684.                 }
  2685.             }
  2686.         }
  2687.  
  2688.     }
  2689.  
  2690.     public class DestroyTask implements Runnable {
  2691.         public DestroyTask() {
  2692.  
  2693.         }
  2694.  
  2695.         @Override
  2696.         public void run() {
  2697.             shrink(true, keepAlive);
  2698.  
  2699.             if (isRemoveAbandoned()) {
  2700.                 removeAbandoned();
  2701.             }
  2702.         }
  2703.  
  2704.     }
  2705.  
  2706.     public class LogStatsThread extends Thread {
  2707.  
  2708.         public LogStatsThread(String name){
  2709.             super(name);
  2710.             this.setDaemon(true);
  2711.         }
  2712.  
  2713.         public void run() {
  2714.             try {
  2715.                 for (;;) {
  2716.                     try {
  2717.                         logStats();
  2718.                     } catch (Exception e) {
  2719.                         LOG.error("logStats error", e);
  2720.                     }
  2721.  
  2722.                     Thread.sleep(timeBetweenLogStatsMillis);
  2723.                 }
  2724.             } catch (InterruptedException e) {
  2725.                 // skip
  2726.             }
  2727.         }
  2728.     }
  2729.  
  2730.     public int removeAbandoned() {
  2731.         int removeCount = 0;
  2732.  
  2733.         long currrentNanos = System.nanoTime();
  2734.  
  2735.         List<DruidPooledConnection> abandonedList = new ArrayList<DruidPooledConnection>();
  2736.  
  2737.         activeConnectionLock.lock();
  2738.         try {
  2739.             Iterator<DruidPooledConnection> iter = activeConnections.keySet().iterator();
  2740.  
  2741.             for (; iter.hasNext();) {
  2742.                 DruidPooledConnection pooledConnection = iter.next();
  2743.  
  2744.                 if (pooledConnection.isRunning()) {
  2745.                     continue;
  2746.                 }
  2747.  
  2748.                 long timeMillis = (currrentNanos - pooledConnection.getConnectedTimeNano()) / (1000 * 1000);
  2749.  
  2750.                 if (timeMillis >= removeAbandonedTimeoutMillis) {
  2751.                     iter.remove();
  2752.                     pooledConnection.setTraceEnable(false);
  2753.                     abandonedList.add(pooledConnection);
  2754.                 }
  2755.             }
  2756.         } finally {
  2757.             activeConnectionLock.unlock();
  2758.         }
  2759.  
  2760.         if (abandonedList.size() > 0) {
  2761.             for (DruidPooledConnection pooledConnection : abandonedList) {
  2762.                 final ReentrantLock lock = pooledConnection.lock;
  2763.                 lock.lock();
  2764.                 try {
  2765.                     if (pooledConnection.isDisable()) {
  2766.                         continue;
  2767.                     }
  2768.                 } finally {
  2769.                     lock.unlock();
  2770.                 }
  2771.  
  2772.                 JdbcUtils.close(pooledConnection);
  2773.                 pooledConnection.abandond();
  2774.                 removeAbandonedCount++;
  2775.                 removeCount++;
  2776.  
  2777.                 if (isLogAbandoned()) {
  2778.                     StringBuilder buf = new StringBuilder();
  2779.                     buf.append("abandon connection, owner thread: ");
  2780.                     buf.append(pooledConnection.getOwnerThread().getName());
  2781.                     buf.append(", connected at : ");
  2782.                     buf.append(pooledConnection.getConnectedTimeMillis());
  2783.                     buf.append(", open stackTrace\n");
  2784.  
  2785.                     StackTraceElement[] trace = pooledConnection.getConnectStackTrace();
  2786.                     for (int i = 0; i < trace.length; i++) {
  2787.                         buf.append("\tat ");
  2788.                         buf.append(trace[i].toString());
  2789.                         buf.append("\n");
  2790.                     }
  2791.  
  2792.                     buf.append("ownerThread current state is " + pooledConnection.getOwnerThread().getState()
  2793.                                + ", current stackTrace\n");
  2794.                     trace = pooledConnection.getOwnerThread().getStackTrace();
  2795.                     for (int i = 0; i < trace.length; i++) {
  2796.                         buf.append("\tat ");
  2797.                         buf.append(trace[i].toString());
  2798.                         buf.append("\n");
  2799.                     }
  2800.  
  2801.                     LOG.error(buf.toString());
  2802.                 }
  2803.             }
  2804.         }
  2805.  
  2806.         return removeCount;
  2807.     }
  2808.  
  2809.     /** Instance key */
  2810.     protected String instanceKey = null;
  2811.  
  2812.     public Reference getReference() throws NamingException {
  2813.         final String className = getClass().getName();
  2814.         final String factoryName = className + "Factory"; // XXX: not robust
  2815.         Reference ref = new Reference(className, factoryName, null);
  2816.         ref.add(new StringRefAddr("instanceKey", instanceKey));
  2817.         ref.add(new StringRefAddr("url", this.getUrl()));
  2818.         ref.add(new StringRefAddr("username", this.getUsername()));
  2819.         ref.add(new StringRefAddr("password", this.getPassword()));
  2820.         // TODO ADD OTHER PROPERTIES
  2821.         return ref;
  2822.     }
  2823.  
  2824.     @Override
  2825.     public List<String> getFilterClassNames() {
  2826.         List<String> names = new ArrayList<String>();
  2827.         for (Filter filter : filters) {
  2828.             names.add(filter.getClass().getName());
  2829.         }
  2830.         return names;
  2831.     }
  2832.  
  2833.     public int getRawDriverMajorVersion() {
  2834.         int version = -1;
  2835.         if (this.driver != null) {
  2836.             version = driver.getMajorVersion();
  2837.         }
  2838.         return version;
  2839.     }
  2840.  
  2841.     public int getRawDriverMinorVersion() {
  2842.         int version = -1;
  2843.         if (this.driver != null) {
  2844.             version = driver.getMinorVersion();
  2845.         }
  2846.         return version;
  2847.     }
  2848.  
  2849.     public String getProperties() {
  2850.         Properties properties = new Properties();
  2851.         properties.putAll(connectProperties);
  2852.         if (properties.containsKey("password")) {
  2853.             properties.put("password", "******");
  2854.         }
  2855.         return properties.toString();
  2856.     }
  2857.  
  2858.     @Override
  2859.     public void shrink() {
  2860.         shrink(false, false);
  2861.     }
  2862.  
  2863.     public void shrink(boolean checkTime) {
  2864.         shrink(checkTime, keepAlive);
  2865.     }
  2866.  
  2867.     public void shrink(boolean checkTime, boolean keepAlive) {
  2868.         try {
  2869.             lock.lockInterruptibly();
  2870.         } catch (InterruptedException e) {
  2871.             return;
  2872.         }
  2873.  
  2874.         int evictCount = 0;
  2875.         int keepAliveCount = 0;
  2876.         try {
  2877.             if (!inited) {
  2878.                 return;
  2879.             }
  2880.  
  2881.             final int checkCount = poolingCount - minIdle;
  2882.             final long currentTimeMillis = System.currentTimeMillis();
  2883.             for (int i = 0; i < poolingCount; ++i) {
  2884.                 DruidConnectionHolder connection = connections[i];
  2885.  
  2886.                 if (checkTime) {
  2887.                     if (phyTimeoutMillis > 0) {
  2888.                         long phyConnectTimeMillis = currentTimeMillis - connection.connectTimeMillis;
  2889.                         if (phyConnectTimeMillis > phyTimeoutMillis) {
  2890.                             evictConnections[evictCount++] = connection;
  2891.                             continue;
  2892.                         }
  2893.                     }
  2894.  
  2895.                     long idleMillis = currentTimeMillis - connection.lastActiveTimeMillis;
  2896.  
  2897.                     if (idleMillis < minEvictableIdleTimeMillis
  2898.                             && idleMillis < keepAliveBetweenTimeMillis
  2899.                     ) {
  2900.                         break;
  2901.                     }
  2902.  
  2903.                     if (idleMillis >= minEvictableIdleTimeMillis) {
  2904.                         if (checkTime && i < checkCount) {
  2905.                             evictConnections[evictCount++] = connection;
  2906.                             continue;
  2907.                         } else if (idleMillis > maxEvictableIdleTimeMillis) {
  2908.                             evictConnections[evictCount++] = connection;
  2909.                             continue;
  2910.                         }
  2911.                     }
  2912.  
  2913.                     if (keepAlive && idleMillis >= keepAliveBetweenTimeMillis) {
  2914.                         keepAliveConnections[keepAliveCount++] = connection;
  2915.                     }
  2916.                 } else {
  2917.                     if (i < checkCount) {
  2918.                         evictConnections[evictCount++] = connection;
  2919.                     } else {
  2920.                         break;
  2921.                     }
  2922.                 }
  2923.             }
  2924.  
  2925.             int removeCount = evictCount + keepAliveCount;
  2926.             if (removeCount > 0) {
  2927.                 System.arraycopy(connections, removeCount, connections, 0, poolingCount - removeCount);
  2928.                 Arrays.fill(connections, poolingCount - removeCount, poolingCount, null);
  2929.                 poolingCount -= removeCount;
  2930.             }
  2931.             keepAliveCheckCount += keepAliveCount;
  2932.         } finally {
  2933.             lock.unlock();
  2934.         }
  2935.  
  2936.         if (evictCount > 0) {
  2937.             for (int i = 0; i < evictCount; ++i) {
  2938.                 DruidConnectionHolder item = evictConnections[i];
  2939.                 Connection connection = item.getConnection();
  2940.                 JdbcUtils.close(connection);
  2941.                 destroyCountUpdater.incrementAndGet(this);
  2942.             }
  2943.             Arrays.fill(evictConnections, null);
  2944.         }
  2945.  
  2946.         if (keepAliveCount > 0) {
  2947.             // keep order
  2948.             for (int i = keepAliveCount - 1; i >= 0; --i) {
  2949.                 DruidConnectionHolder holer = keepAliveConnections[i];
  2950.                 Connection connection = holer.getConnection();
  2951.                 holer.incrementKeepAliveCheckCount();
  2952.  
  2953.                 boolean validate = false;
  2954.                 try {
  2955.                     this.validateConnection(connection);
  2956.                     validate = true;
  2957.                 } catch (Throwable error) {
  2958.                     if (LOG.isDebugEnabled()) {
  2959.                         LOG.debug("keepAliveErr", error);
  2960.                     }
  2961.                     // skip
  2962.                 }
  2963.  
  2964.                 boolean discard = !validate;
  2965.                 if (validate) {
  2966.                     holer.lastKeepTimeMillis = System.currentTimeMillis();
  2967.                     boolean putOk = put(holer);
  2968.                     if (!putOk) {
  2969.                         discard = true;
  2970.                     }
  2971.                 }
  2972.  
  2973.                 if (discard) {
  2974.                     try {
  2975.                         connection.close();
  2976.                     } catch (Exception e) {
  2977.                         // skip
  2978.                     }
  2979.  
  2980.                     lock.lock();
  2981.                     try {
  2982.                         discardCount++;
  2983.  
  2984.                         if (activeCount <= minIdle) {
  2985.                             emptySignal();
  2986.                         }
  2987.                     } finally {
  2988.                         lock.unlock();
  2989.                     }
  2990.                 }
  2991.             }
  2992.             this.getDataSourceStat().addKeepAliveCheckCount(keepAliveCount);
  2993.             Arrays.fill(keepAliveConnections, null);
  2994.         }
  2995.     }
  2996.  
  2997.     public int getWaitThreadCount() {
  2998.         lock.lock();
  2999.         try {
  3000.             return lock.getWaitQueueLength(notEmpty);
  3001.         } finally {
  3002.             lock.unlock();
  3003.         }
  3004.     }
  3005.  
  3006.     public long getNotEmptyWaitCount() {
  3007.         return notEmptyWaitCount;
  3008.     }
  3009.  
  3010.     public int getNotEmptyWaitThreadCount() {
  3011.         lock.lock();
  3012.         try {
  3013.             return notEmptyWaitThreadCount;
  3014.         } finally {
  3015.             lock.unlock();
  3016.         }
  3017.     }
  3018.  
  3019.     public int getNotEmptyWaitThreadPeak() {
  3020.         lock.lock();
  3021.         try {
  3022.             return notEmptyWaitThreadPeak;
  3023.         } finally {
  3024.             lock.unlock();
  3025.         }
  3026.     }
  3027.  
  3028.     public long getNotEmptySignalCount() {
  3029.         return notEmptySignalCount;
  3030.     }
  3031.  
  3032.     public long getNotEmptyWaitMillis() {
  3033.         return notEmptyWaitNanos / (1000 * 1000);
  3034.     }
  3035.  
  3036.     public long getNotEmptyWaitNanos() {
  3037.         return notEmptyWaitNanos;
  3038.     }
  3039.  
  3040.     public int getLockQueueLength() {
  3041.         return lock.getQueueLength();
  3042.     }
  3043.  
  3044.     public int getActivePeak() {
  3045.         return activePeak;
  3046.     }
  3047.  
  3048.     public Date getActivePeakTime() {
  3049.         if (activePeakTime <= 0) {
  3050.             return null;
  3051.         }
  3052.  
  3053.         return new Date(activePeakTime);
  3054.     }
  3055.  
  3056.     public String dump() {
  3057.         lock.lock();
  3058.         try {
  3059.             return this.toString();
  3060.         } finally {
  3061.             lock.unlock();
  3062.         }
  3063.     }
  3064.  
  3065.     public long getErrorCount() {
  3066.         return this.errorCount;
  3067.     }
  3068.  
  3069.     public String toString() {
  3070.         StringBuilder buf = new StringBuilder();
  3071.  
  3072.         buf.append("{");
  3073.  
  3074.         buf.append("\n\tCreateTime:\"");
  3075.         buf.append(Utils.toString(getCreatedTime()));
  3076.         buf.append("\"");
  3077.  
  3078.         buf.append(",\n\tActiveCount:");
  3079.         buf.append(getActiveCount());
  3080.  
  3081.         buf.append(",\n\tPoolingCount:");
  3082.         buf.append(getPoolingCount());
  3083.  
  3084.         buf.append(",\n\tCreateCount:");
  3085.         buf.append(getCreateCount());
  3086.  
  3087.         buf.append(",\n\tDestroyCount:");
  3088.         buf.append(getDestroyCount());
  3089.  
  3090.         buf.append(",\n\tCloseCount:");
  3091.         buf.append(getCloseCount());
  3092.  
  3093.         buf.append(",\n\tConnectCount:");
  3094.         buf.append(getConnectCount());
  3095.  
  3096.         buf.append(",\n\tConnections:[");
  3097.         for (int i = 0; i < poolingCount; ++i) {
  3098.             DruidConnectionHolder conn = connections[i];
  3099.             if (conn != null) {
  3100.                 if (i != 0) {
  3101.                     buf.append(",");
  3102.                 }
  3103.                 buf.append("\n\t\t");
  3104.                 buf.append(conn.toString());
  3105.             }
  3106.         }
  3107.         buf.append("\n\t]");
  3108.  
  3109.         buf.append("\n}");
  3110.  
  3111.         if (this.isPoolPreparedStatements()) {
  3112.             buf.append("\n\n[");
  3113.             for (int i = 0; i < poolingCount; ++i) {
  3114.                 DruidConnectionHolder conn = connections[i];
  3115.                 if (conn != null) {
  3116.                     if (i != 0) {
  3117.                         buf.append(",");
  3118.                     }
  3119.                     buf.append("\n\t{\n\tID:");
  3120.                     buf.append(System.identityHashCode(conn.getConnection()));
  3121.                     PreparedStatementPool pool = conn.getStatementPool();
  3122.  
  3123.                     buf.append(", \n\tpoolStatements:[");
  3124.  
  3125.                     int entryIndex = 0;
  3126.                     try {
  3127.                         for (Map.Entry<PreparedStatementKey, PreparedStatementHolder> entry : pool.getMap().entrySet()) {
  3128.                             if (entryIndex != 0) {
  3129.                                 buf.append(",");
  3130.                             }
  3131.                             buf.append("\n\t\t{hitCount:");
  3132.                             buf.append(entry.getValue().getHitCount());
  3133.                             buf.append(",sql:\"");
  3134.                             buf.append(entry.getKey().getSql());
  3135.                             buf.append("\"");
  3136.                             buf.append("\t}");
  3137.  
  3138.                             entryIndex++;
  3139.                         }
  3140.                     } catch (ConcurrentModificationException e) {
  3141.                         // skip ..
  3142.                     }
  3143.  
  3144.                     buf.append("\n\t\t]");
  3145.  
  3146.                     buf.append("\n\t}");
  3147.                 }
  3148.             }
  3149.             buf.append("\n]");
  3150.         }
  3151.  
  3152.         return buf.toString();
  3153.     }
  3154.  
  3155.     public List<Map<String, Object>> getPoolingConnectionInfo() {
  3156.         List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
  3157.         lock.lock();
  3158.         try {
  3159.             for (int i = 0; i < poolingCount; ++i) {
  3160.                 DruidConnectionHolder connHolder = connections[i];
  3161.                 Connection conn = connHolder.getConnection();
  3162.  
  3163.                 Map<String, Object> map = new LinkedHashMap<String, Object>();
  3164.                 map.put("id", System.identityHashCode(conn));
  3165.                 map.put("connectionId", connHolder.getConnectionId());
  3166.                 map.put("useCount", connHolder.getUseCount());
  3167.                 if (connHolder.lastActiveTimeMillis > 0) {
  3168.                     map.put("lastActiveTime", new Date(connHolder.lastActiveTimeMillis));
  3169.                 }
  3170.                 if (connHolder.lastKeepTimeMillis > 0) {
  3171.                     map.put("lastKeepTimeMillis", new Date(connHolder.lastKeepTimeMillis));
  3172.                 }
  3173.                 map.put("connectTime", new Date(connHolder.getTimeMillis()));
  3174.                 map.put("holdability", connHolder.getUnderlyingHoldability());
  3175.                 map.put("transactionIsolation", connHolder.getUnderlyingTransactionIsolation());
  3176.                 map.put("autoCommit", connHolder.underlyingAutoCommit);
  3177.                 map.put("readoOnly", connHolder.isUnderlyingReadOnly());
  3178.  
  3179.                 if (connHolder.isPoolPreparedStatements()) {
  3180.                     List<Map<String, Object>> stmtCache = new ArrayList<Map<String, Object>>();
  3181.                     PreparedStatementPool stmtPool = connHolder.getStatementPool();
  3182.                     for (PreparedStatementHolder stmtHolder : stmtPool.getMap().values()) {
  3183.                         Map<String, Object> stmtInfo = new LinkedHashMap<String, Object>();
  3184.  
  3185.                         stmtInfo.put("sql", stmtHolder.key.getSql());
  3186.                         stmtInfo.put("defaultRowPrefetch", stmtHolder.getDefaultRowPrefetch());
  3187.                         stmtInfo.put("rowPrefetch", stmtHolder.getRowPrefetch());
  3188.                         stmtInfo.put("hitCount", stmtHolder.getHitCount());
  3189.  
  3190.                         stmtCache.add(stmtInfo);
  3191.                     }
  3192.  
  3193.                     map.put("pscache", stmtCache);
  3194.                 }
  3195.                 map.put("keepAliveCheckCount", connHolder.getKeepAliveCheckCount());
  3196.  
  3197.                 list.add(map);
  3198.             }
  3199.         } finally {
  3200.             lock.unlock();
  3201.         }
  3202.         return list;
  3203.     }
  3204.  
  3205.     public void logTransaction(TransactionInfo info) {
  3206.         long transactionMillis = info.getEndTimeMillis() - info.getStartTimeMillis();
  3207.         if (transactionThresholdMillis > 0 && transactionMillis > transactionThresholdMillis) {
  3208.             StringBuilder buf = new StringBuilder();
  3209.             buf.append("long time transaction, take ");
  3210.             buf.append(transactionMillis);
  3211.             buf.append(" ms : ");
  3212.             for (String sql : info.getSqlList()) {
  3213.                 buf.append(sql);
  3214.                 buf.append(";");
  3215.             }
  3216.             LOG.error(buf.toString(), new TransactionTimeoutException());
  3217.         }
  3218.     }
  3219.  
  3220.     @Override
  3221.     public String getVersion() {
  3222.         return VERSION.getVersionNumber();
  3223.     }
  3224.  
  3225.     @Override
  3226.     public JdbcDataSourceStat getDataSourceStat() {
  3227.         return dataSourceStat;
  3228.     }
  3229.  
  3230.     public Object clone() throws CloneNotSupportedException {
  3231.         return cloneDruidDataSource();
  3232.     }
  3233.  
  3234.     public DruidDataSource cloneDruidDataSource() {
  3235.         DruidDataSource x = new DruidDataSource();
  3236.  
  3237.         cloneTo(x);
  3238.  
  3239.         return x;
  3240.     }
  3241.  
  3242.     public Map<String, Object> getStatDataForMBean() {
  3243.         try {
  3244.             Map<String, Object> map = new HashMap<String, Object>();
  3245.  
  3246.             // 0 - 4
  3247.             map.put("Name", this.getName());
  3248.             map.put("URL", this.getUrl());
  3249.             map.put("CreateCount", this.getCreateCount());
  3250.             map.put("DestroyCount", this.getDestroyCount());
  3251.             map.put("ConnectCount", this.getConnectCount());
  3252.  
  3253.             // 5 - 9
  3254.             map.put("CloseCount", this.getCloseCount());
  3255.             map.put("ActiveCount", this.getActiveCount());
  3256.             map.put("PoolingCount", this.getPoolingCount());
  3257.             map.put("LockQueueLength", this.getLockQueueLength());
  3258.             map.put("WaitThreadCount", this.getNotEmptyWaitThreadPeak());
  3259.  
  3260.             // 10 - 14
  3261.             map.put("InitialSize", this.getInitialSize());
  3262.             map.put("MaxActive", this.getMaxActive());
  3263.             map.put("MinIdle", this.getMinIdle());
  3264.             map.put("PoolPreparedStatements", this.isPoolPreparedStatements());
  3265.             map.put("TestOnBorrow", this.isTestOnBorrow());
  3266.  
  3267.             // 15 - 19
  3268.             map.put("TestOnReturn", this.isTestOnReturn());
  3269.             map.put("MinEvictableIdleTimeMillis", this.minEvictableIdleTimeMillis);
  3270.             map.put("ConnectErrorCount", this.getConnectErrorCount());
  3271.             map.put("CreateTimespanMillis", this.getCreateTimespanMillis());
  3272.             map.put("DbType", this.dbType);
  3273.  
  3274.             // 20 - 24
  3275.             map.put("ValidationQuery", this.getValidationQuery());
  3276.             map.put("ValidationQueryTimeout", this.getValidationQueryTimeout());
  3277.             map.put("DriverClassName", this.getDriverClassName());
  3278.             map.put("Username", this.getUsername());
  3279.             map.put("RemoveAbandonedCount", this.getRemoveAbandonedCount());
  3280.  
  3281.             // 25 - 29
  3282.             map.put("NotEmptyWaitCount", this.getNotEmptyWaitCount());
  3283.             map.put("NotEmptyWaitNanos", this.getNotEmptyWaitNanos());
  3284.             map.put("ErrorCount", this.getErrorCount());
  3285.             map.put("ReusePreparedStatementCount", this.getCachedPreparedStatementHitCount());
  3286.             map.put("StartTransactionCount", this.getStartTransactionCount());
  3287.  
  3288.             // 30 - 34
  3289.             map.put("CommitCount", this.getCommitCount());
  3290.             map.put("RollbackCount", this.getRollbackCount());
  3291.             map.put("LastError", JMXUtils.getErrorCompositeData(this.getLastError()));
  3292.             map.put("LastCreateError", JMXUtils.getErrorCompositeData(this.getLastCreateError()));
  3293.             map.put("PreparedStatementCacheDeleteCount", this.getCachedPreparedStatementDeleteCount());
  3294.  
  3295.             // 35 - 39
  3296.             map.put("PreparedStatementCacheAccessCount", this.getCachedPreparedStatementAccessCount());
  3297.             map.put("PreparedStatementCacheMissCount", this.getCachedPreparedStatementMissCount());
  3298.             map.put("PreparedStatementCacheHitCount", this.getCachedPreparedStatementHitCount());
  3299.             map.put("PreparedStatementCacheCurrentCount", this.getCachedPreparedStatementCount());
  3300.             map.put("Version", this.getVersion());
  3301.  
  3302.             // 40 -
  3303.             map.put("LastErrorTime", this.getLastErrorTime());
  3304.             map.put("LastCreateErrorTime", this.getLastCreateErrorTime());
  3305.             map.put("CreateErrorCount", this.getCreateErrorCount());
  3306.             map.put("DiscardCount", this.getDiscardCount());
  3307.             map.put("ExecuteQueryCount", this.getExecuteQueryCount());
  3308.  
  3309.             map.put("ExecuteUpdateCount", this.getExecuteUpdateCount());
  3310.  
  3311.             return map;
  3312.         } catch (JMException ex) {
  3313.             throw new IllegalStateException("getStatData error", ex);
  3314.         }
  3315.     }
  3316.  
  3317.     public Map<String, Object> getStatData() {
  3318.         final int activeCount;
  3319.         final int activePeak;
  3320.         final Date activePeakTime;
  3321.  
  3322.         final int poolingCount;
  3323.         final int poolingPeak;
  3324.         final Date poolingPeakTime;
  3325.  
  3326.         final long connectCount;
  3327.         final long closeCount;
  3328.  
  3329.         lock.lock();
  3330.         try {
  3331.             poolingCount = this.poolingCount;
  3332.             poolingPeak = this.poolingPeak;
  3333.             poolingPeakTime = this.getPoolingPeakTime();
  3334.  
  3335.             activeCount = this.activeCount;
  3336.             activePeak = this.activePeak;
  3337.             activePeakTime = this.getActivePeakTime();
  3338.  
  3339.             connectCount = this.connectCount;
  3340.             closeCount = this.closeCount;
  3341.         } finally {
  3342.             lock.unlock();
  3343.         }
  3344.         Map<String, Object> dataMap = new LinkedHashMap<String, Object>();
  3345.  
  3346.         dataMap.put("Identity", System.identityHashCode(this));
  3347.         dataMap.put("Name", this.getName());
  3348.         dataMap.put("DbType", this.dbType);
  3349.         dataMap.put("DriverClassName", this.getDriverClassName());
  3350.  
  3351.         dataMap.put("URL", this.getUrl());
  3352.         dataMap.put("UserName", this.getUsername());
  3353.         dataMap.put("FilterClassNames", this.getFilterClassNames());
  3354.  
  3355.         dataMap.put("WaitThreadCount", this.getWaitThreadCount());
  3356.         dataMap.put("NotEmptyWaitCount", this.getNotEmptyWaitCount());
  3357.         dataMap.put("NotEmptyWaitMillis", this.getNotEmptyWaitMillis());
  3358.  
  3359.         dataMap.put("PoolingCount", poolingCount);
  3360.         dataMap.put("PoolingPeak", poolingPeak);
  3361.         dataMap.put("PoolingPeakTime", poolingPeakTime);
  3362.  
  3363.         dataMap.put("ActiveCount", activeCount);
  3364.         dataMap.put("ActivePeak", activePeak);
  3365.         dataMap.put("ActivePeakTime", activePeakTime);
  3366.  
  3367.         dataMap.put("InitialSize", this.getInitialSize());
  3368.         dataMap.put("MinIdle", this.getMinIdle());
  3369.         dataMap.put("MaxActive", this.getMaxActive());
  3370.  
  3371.         dataMap.put("QueryTimeout", this.getQueryTimeout());
  3372.         dataMap.put("TransactionQueryTimeout", this.getTransactionQueryTimeout());
  3373.         dataMap.put("LoginTimeout", this.getLoginTimeout());
  3374.         dataMap.put("ValidConnectionCheckerClassName", this.getValidConnectionCheckerClassName());
  3375.         dataMap.put("ExceptionSorterClassName", this.getExceptionSorterClassName());
  3376.  
  3377.         dataMap.put("TestOnBorrow", this.isTestOnBorrow());
  3378.         dataMap.put("TestOnReturn", this.isTestOnReturn());
  3379.         dataMap.put("TestWhileIdle", this.isTestWhileIdle());
  3380.  
  3381.         dataMap.put("DefaultAutoCommit", this.isDefaultAutoCommit());
  3382.         dataMap.put("DefaultReadOnly", this.getDefaultReadOnly());
  3383.         dataMap.put("DefaultTransactionIsolation", this.getDefaultTransactionIsolation());
  3384.  
  3385.         dataMap.put("LogicConnectCount", connectCount);
  3386.         dataMap.put("LogicCloseCount", closeCount);
  3387.         dataMap.put("LogicConnectErrorCount", this.getConnectErrorCount());
  3388.  
  3389.         dataMap.put("PhysicalConnectCount", this.getCreateCount());
  3390.         dataMap.put("PhysicalCloseCount", this.getDestroyCount());
  3391.         dataMap.put("PhysicalConnectErrorCount", this.getCreateErrorCount());
  3392.  
  3393.         dataMap.put("ExecuteCount", this.getExecuteCount());
  3394.         dataMap.put("ExecuteUpdateCount", this.getExecuteUpdateCount());
  3395.         dataMap.put("ExecuteQueryCount", this.getExecuteQueryCount());
  3396.         dataMap.put("ExecuteBatchCount", this.getExecuteBatchCount());
  3397.         dataMap.put("ErrorCount", this.getErrorCount());
  3398.         dataMap.put("CommitCount", this.getCommitCount());
  3399.         dataMap.put("RollbackCount", this.getRollbackCount());
  3400.  
  3401.         dataMap.put("PSCacheAccessCount", this.getCachedPreparedStatementAccessCount());
  3402.         dataMap.put("PSCacheHitCount", this.getCachedPreparedStatementHitCount());
  3403.         dataMap.put("PSCacheMissCount", this.getCachedPreparedStatementMissCount());
  3404.  
  3405.         dataMap.put("StartTransactionCount", this.getStartTransactionCount());
  3406.         dataMap.put("TransactionHistogram", this.getTransactionHistogramValues());
  3407.  
  3408.         dataMap.put("ConnectionHoldTimeHistogram", this.getDataSourceStat().getConnectionHoldHistogram().toArray());
  3409.         dataMap.put("RemoveAbandoned", this.isRemoveAbandoned());
  3410.         dataMap.put("ClobOpenCount", this.getDataSourceStat().getClobOpenCount());
  3411.         dataMap.put("BlobOpenCount", this.getDataSourceStat().getBlobOpenCount());
  3412.         dataMap.put("KeepAliveCheckCount", this.getDataSourceStat().getKeepAliveCheckCount());
  3413.  
  3414.         dataMap.put("KeepAlive", this.isKeepAlive());
  3415.         dataMap.put("FailFast", this.isFailFast());
  3416.         dataMap.put("MaxWait", this.getMaxWait());
  3417.         dataMap.put("MaxWaitThreadCount", this.getMaxWaitThreadCount());
  3418.         dataMap.put("PoolPreparedStatements", this.isPoolPreparedStatements());
  3419.         dataMap.put("MaxPoolPreparedStatementPerConnectionSize", this.getMaxPoolPreparedStatementPerConnectionSize());
  3420.         dataMap.put("MinEvictableIdleTimeMillis", this.minEvictableIdleTimeMillis);
  3421.         dataMap.put("MaxEvictableIdleTimeMillis", this.maxEvictableIdleTimeMillis);
  3422.  
  3423.         dataMap.put("LogDifferentThread", isLogDifferentThread());
  3424.         dataMap.put("RecycleErrorCount", getRecycleErrorCount());
  3425.         dataMap.put("PreparedStatementOpenCount", getPreparedStatementCount());
  3426.         dataMap.put("PreparedStatementClosedCount", getClosedPreparedStatementCount());
  3427.  
  3428.         dataMap.put("UseUnfairLock", isUseUnfairLock());
  3429.         dataMap.put("InitGlobalVariants", isInitGlobalVariants());
  3430.         dataMap.put("InitVariants", isInitVariants());
  3431.         return dataMap;
  3432.     }
  3433.  
  3434.     public JdbcSqlStat getSqlStat(int sqlId) {
  3435.         return this.getDataSourceStat().getSqlStat(sqlId);
  3436.     }
  3437.  
  3438.     public JdbcSqlStat getSqlStat(long sqlId) {
  3439.         return this.getDataSourceStat().getSqlStat(sqlId);
  3440.     }
  3441.  
  3442.     public Map<String, JdbcSqlStat> getSqlStatMap() {
  3443.         return this.getDataSourceStat().getSqlStatMap();
  3444.     }
  3445.  
  3446.     public Map<String, Object> getWallStatMap() {
  3447.         WallProviderStatValue wallStatValue = getWallStatValue(false);
  3448.  
  3449.         if (wallStatValue != null) {
  3450.             return wallStatValue.toMap();
  3451.         }
  3452.  
  3453.         return null;
  3454.     }
  3455.  
  3456.     public WallProviderStatValue getWallStatValue(boolean reset) {
  3457.         for (Filter filter : this.filters) {
  3458.             if (filter instanceof WallFilter) {
  3459.                 WallFilter wallFilter = (WallFilter) filter;
  3460.                 return wallFilter.getProvider().getStatValue(reset);
  3461.             }
  3462.         }
  3463.  
  3464.         return null;
  3465.     }
  3466.  
  3467.     public Lock getLock() {
  3468.         return lock;
  3469.     }
  3470.  
  3471.     @Override
  3472.     public boolean isWrapperFor(Class<?> iface) {
  3473.         for (Filter filter : this.filters) {
  3474.             if (filter.isWrapperFor(iface)) {
  3475.                 return true;
  3476.             }
  3477.         }
  3478.  
  3479.         if (this.statLogger != null
  3480.             && (this.statLogger.getClass() == iface || DruidDataSourceStatLogger.class == iface)) {
  3481.             return true;
  3482.         }
  3483.  
  3484.         return super.isWrapperFor(iface);
  3485.     }
  3486.  
  3487.     @SuppressWarnings("unchecked")
  3488.     public <T> T unwrap(Class<T> iface) {
  3489.         for (Filter filter : this.filters) {
  3490.             if (filter.isWrapperFor(iface)) {
  3491.                 return (T) filter;
  3492.             }
  3493.         }
  3494.  
  3495.         if (this.statLogger != null
  3496.             && (this.statLogger.getClass() == iface || DruidDataSourceStatLogger.class == iface)) {
  3497.             return (T) statLogger;
  3498.         }
  3499.  
  3500.         return super.unwrap(iface);
  3501.     }
  3502.  
  3503.     public boolean isLogDifferentThread() {
  3504.         return logDifferentThread;
  3505.     }
  3506.  
  3507.     public void setLogDifferentThread(boolean logDifferentThread) {
  3508.         this.logDifferentThread = logDifferentThread;
  3509.     }
  3510.  
  3511.     public DruidPooledConnection tryGetConnection() throws SQLException {
  3512.         if (poolingCount == 0) {
  3513.             return null;
  3514.         }
  3515.         return getConnection();
  3516.     }
  3517.  
  3518.     @Override
  3519.     public int fill() throws SQLException {
  3520.         return this.fill(this.maxActive);
  3521.     }
  3522.  
  3523.     @Override
  3524.     public int fill(int toCount) throws SQLException {
  3525.         if (closed) {
  3526.             throw new DataSourceClosedException("dataSource already closed at " + new Date(closeTimeMillis));
  3527.         }
  3528.  
  3529.         if (toCount < 0) {
  3530.             throw new IllegalArgumentException("toCount can't not be less than zero");
  3531.         }
  3532.  
  3533.         init();
  3534.  
  3535.         if (toCount > this.maxActive) {
  3536.             toCount = this.maxActive;
  3537.         }
  3538.  
  3539.         int fillCount = 0;
  3540.         for (;;) {
  3541.             try {
  3542.                 lock.lockInterruptibly();
  3543.             } catch (InterruptedException e) {
  3544.                 connectErrorCountUpdater.incrementAndGet(this);
  3545.                 throw new SQLException("interrupt", e);
  3546.             }
  3547.  
  3548.             boolean fillable = this.isFillable(toCount);
  3549.  
  3550.             lock.unlock();
  3551.  
  3552.             if (!fillable) {
  3553.                 break;
  3554.             }
  3555.  
  3556.             DruidConnectionHolder holder;
  3557.             try {
  3558.                 PhysicalConnectionInfo pyConnInfo = createPhysicalConnection();
  3559.                 holder = new DruidConnectionHolder(this, pyConnInfo);
  3560.             } catch (SQLException e) {
  3561.                 LOG.error("fill connection error, url: " + this.jdbcUrl, e);
  3562.                 connectErrorCountUpdater.incrementAndGet(this);
  3563.                 throw e;
  3564.             }
  3565.  
  3566.             try {
  3567.                 lock.lockInterruptibly();
  3568.             } catch (InterruptedException e) {
  3569.                 connectErrorCountUpdater.incrementAndGet(this);
  3570.                 throw new SQLException("interrupt", e);
  3571.             }
  3572.  
  3573.             try {
  3574.                 if (!this.isFillable(toCount)) {
  3575.                     JdbcUtils.close(holder.getConnection());
  3576.                     LOG.info("fill connections skip.");
  3577.                     break;
  3578.                 }
  3579.                 this.putLast(holder, System.currentTimeMillis());
  3580.                 fillCount++;
  3581.             } finally {
  3582.                 lock.unlock();
  3583.             }
  3584.         }
  3585.  
  3586.         if (LOG.isInfoEnabled()) {
  3587.             LOG.info("fill " + fillCount + " connections");
  3588.         }
  3589.  
  3590.         return fillCount;
  3591.     }
  3592.  
  3593.     private boolean isFillable(int toCount) {
  3594.         int currentCount = this.poolingCount + this.activeCount;
  3595.         if (currentCount >= toCount || currentCount >= this.maxActive) {
  3596.             return false;
  3597.         } else {
  3598.             return true;
  3599.         }
  3600.     }
  3601.  
  3602.     public boolean isFull() {
  3603.         lock.lock();
  3604.         try {
  3605.             return this.poolingCount + this.activeCount >= this.maxActive;
  3606.         } finally {
  3607.             lock.unlock();
  3608.         }
  3609.     }
  3610.  
  3611.     private void emptySignal() {
  3612.         if (createScheduler == null) {
  3613.             empty.signal();
  3614.             return;
  3615.         }
  3616.  
  3617.         if (createTaskCount >= maxCreateTaskCount) {
  3618.             return;
  3619.         }
  3620.  
  3621.         if (activeCount + poolingCount + createTaskCount >= maxActive) {
  3622.             return;
  3623.         }
  3624.  
  3625.         createTaskCount++;
  3626.         CreateConnectionTask task = new CreateConnectionTask();
  3627.         this.createSchedulerFuture = createScheduler.submit(task);
  3628.     }
  3629.  
  3630.     @Override
  3631.     public ObjectName preRegister(MBeanServer server, ObjectName name) throws Exception {
  3632.         if (server != null) {
  3633.             try {
  3634.                 if (server.isRegistered(name)) {
  3635.                     server.unregisterMBean(name);
  3636.                 }
  3637.             } catch (Exception ex) {
  3638.                 LOG.warn("DruidDataSource preRegister error", ex);
  3639.             }
  3640.         }
  3641.         return name;
  3642.     }
  3643.  
  3644.     @Override
  3645.     public void postRegister(Boolean registrationDone) {
  3646.  
  3647.     }
  3648.  
  3649.     @Override
  3650.     public void preDeregister() throws Exception {
  3651.  
  3652.     }
  3653.  
  3654.     @Override
  3655.     public void postDeregister() {
  3656.  
  3657.     }
  3658.  
  3659.     public boolean isClosed() {
  3660.         return this.closed;
  3661.     }
  3662. }

参考阅读

Java魔法类：Unsafe应用解析

面试官：说说 Java 中的 Unsafe 和 CAS

sun.misc.Unsafe.park(Native Method)异常

深入理解sun.misc.Unsafe原理

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/336970
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号