前言：
作为一个比较流行的数据库连接池框架，Druid以其功能强大、易于扩展而著称。
使用连接池的好处不言而喻，在之前的Mysql-java的博客中，我们看到，创建一个数据库连接不仅需要常规的三次握手，还要进行用户名密码验证，经历这么多验证之后，才算真正完成一个连接。如果我们执行一次SQL操作均要重新创建连接，那将是巨大的浪费。
故使用连接池，可以在项目启动时预先创建好一定数量的连接，执行SQL时，从连接池中获取即可，执行完毕后，将连接释放，还回连接池中。
DruidPool在创建时，需要N多参数，这些参数有些是必须项，有些是优化项，有些则是扩展项。我们就从这些参数的角度来从分析下Druid的源码。
建议可以带着问题来看Druid的源码，比如Druid是如何创建连接的，有哪些必备参数，连接如何被回收，连接的有效性如何鉴定。这样的话，我们再来看这些参数对应的源码就会恍然大悟。
1.环境准备：
mysql-server：5.7.17
mysql-connector-java：5.1.41
druid：1.1.23
2.代码准备：
DruidDataSource dataSource = new DruidDataSource();
// 以下四个参数为必输项
dataSource.setUrl("jdbc:mysql://localhost:3306/db1");
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUsername("root");
dataSource.setPassword("root");
// 如果使用在项目中，建议主动调用init方法，初始化连接池
dataSource.init();
// 获取连接
Connection connection = dataSource.getConnection();
// 执行SQL
Statement stmt = connection.createStatement();
stmt.execute("select 1;");
// 获取结果集
ResultSet rs = stmt.getResultSet();总结：在创建DruidDataSource的时候，我们定义了四个必须参数，实际这个也是我们之前使用DriverManager创建连接时的四个必须参数。这里就不再赘述。
3.连接池中连接数量相关参数
initialSize：启动连接时，在连接池中初始化的连接个数
maxActive：连接池中最多支持的活动会话个数
minIdle：回收空闲连接时，将保证至少有minIdle个连接
3.1 initialSize的使用
// DruidDataSource.init 初始化方法，在创建DruidDataSource完成后，默认初始化initialSize个连接
public void init() throws SQLException {
// 初始化状态，只会被初始化一次
if (inited) {
return;
}
...
initFromSPIServiceLoader();
resolveDriver();
initCheck();
...
// init connections
while (poolingCount < initialSize) {
try {
// initialSize的使用在这里，poolingCount默认为0，故会初始化initialSize个连接
PhysicalConnectionInfo pyConnectInfo = createPhysicalConnection();
DruidConnectionHolder holder = new DruidConnectionHolder(this, pyConnectInfo);
connections[poolingCount++] = holder;
} catch (SQLException ex) {
LOG.error("init datasource error, url: " + this.getUrl(), ex);
if (initExceptionThrow) {
connectError = ex;
break;
} else {
Thread.sleep(3000);
}
}
}
}
总结：initialSize比较简单，在DruidDataSource.init()方法调用完成后，默认会初始化initialSize个连接。所以建议在使用Spring创建DruidDataSource bean时，初始调用一下init方法，否则在第一次获取连接时会先执行init方法，拖慢第一次获取连接的速度。
3.2 maxActive的使用
// DruidDataSource.getConnectionDirect --> DruidDataSource.getConnectionInternal
// 直接获取连接时，要么直接从已创建好的连接池中获取，要么创建新的连接，这时maxActive就会派上用场
private DruidPooledConnection getConnectionInternal(long maxWait) throws SQLException {
if (closed) {
connectErrorCountUpdater.incrementAndGet(this);
throw new DataSourceClosedException("dataSource already closed at " + new Date(closeTimeMillis));
}
...
for (boolean createDirect = false;;) {
// createDirect什么时候会为true，看下面2的逻辑
if (createDirect) {
PhysicalConnectionInfo pyConnInfo = DruidDataSource.this.createPhysicalConnection();
holder = new DruidConnectionHolder(this, pyConnInfo);
holder.lastActiveTimeMillis = System.currentTimeMillis();
try {
// 此时maxActive排上用场，如果活跃的连接数大于maxActive，则discard
if (activeCount < maxActive) {
activeCount++;
holder.active = true;
if (activeCount > activePeak) {
activePeak = activeCount;
activePeakTime = System.currentTimeMillis();
}
break;
} else {
discard = true;
}
} finally {
lock.unlock();
}
// 超过maxActive的连接，则直接close掉
if (discard) {
JdbcUtils.close(pyConnInfo.getPhysicalConnection());
}
}
...
// 2
if (createScheduler != null
&& poolingCount == 0
&& activeCount < maxActive
&& creatingCountUpdater.get(this) == 0
&& createScheduler instanceof ScheduledThreadPoolExecutor) {
ScheduledThreadPoolExecutor executor = (ScheduledThreadPoolExecutor) createScheduler;
if (executor.getQueue().size() > 0) {
// 当poolingCount==0,也就是预创建连接池中的连接全部被占用
// 此时会执行上面的直接创建连接的逻辑
createDirect = true;
continue;
}
}
}
}
总结：当连接池中的连接全部被占用时，允许创建新的连接，但是总的连接数不能大于maxActive
3.3 minIdle的使用
// DruidDataSource.shrink
public void shrink(boolean checkTime, boolean keepAlive) {
final int checkCount = poolingCount - minIdle;
final long currentTimeMillis = System.currentTimeMillis();
for (int i = 0; i < poolingCount; ++i) {
DruidConnectionHolder connection = connections[i];
if (checkTime) {
if (phyTimeoutMillis > 0) {
long phyConnectTimeMillis = currentTimeMillis - connection.connectTimeMillis;
if (phyConnectTimeMillis > phyTimeoutMillis) {
evictConnections[evictCount++] = connection;
continue;
}
}
}
...
}
// 对minIdle之外的连接进行回收操作
int removeCount = evictCount + keepAliveCount;
if (removeCount > 0) {
System.arraycopy(connections, removeCount, connections, 0, poolingCount - removeCount);
Arrays.fill(connections, poolingCount - removeCount, poolingCount, null);
poolingCount -= removeCount;
}
keepAliveCheckCount += keepAliveCount;
if (keepAlive && poolingCount + activeCount < minIdle) {
needFill = true;
}
}
总结：当连接长时间不被使用时，会对其进行回收，当然，不是全部空闲连接都被回收，至少要保留minIdle个
4.连接池中连接有效性校验相关参数
4.1 获取连接时有效性检查
testWhileIdle：当程序请求连接时，连接池在分配连接时，是否先检查该连接是否有效
validationQuery：检查池中的连接是否仍有可用的SQL语句，druid会连接到数据库执行该SQL，如果正常返回，则表示连接可用，否则连接不可用
testOnBorrow：程序申请连接时，进行有效性检查
testOnReturn：程序返还连接时，进行连接有效性检查
1）testWhileIdle、testOnBorrow的使用
// DruidDataSource.getConnectionDirect
public DruidPooledConnection getConnectionDirect(long maxWaitMillis) throws SQLException {
// testOnBorrow参数
if (testOnBorrow) {
// mysql下，默认使用MySqlValidConnectionChecker
// 实际上就是使用MysqlConnection.pingInternal方法进行ping操作
boolean validate = testConnectionInternal(poolableConnection.holder, poolableConnection.conn);
if (!validate) {
if (LOG.isDebugEnabled()) {
LOG.debug("skip not validate connection.");
}
discardConnection(poolableConnection.holder);
continue;
}
}else {
...
if (testWhileIdle) {
final DruidConnectionHolder holder = poolableConnection.holder;
long idleMillis = currentTimeMillis - lastActiveTimeMillis;
long timeBetweenEvictionRunsMillis = this.timeBetweenEvictionRunsMillis;
if (timeBetweenEvictionRunsMillis <= 0) {
timeBetweenEvictionRunsMillis = DEFAULT_TIME_BETWEEN_EVICTION_RUNS_MILLIS;
}
// 如果当前连接空闲时间过长，超过我们指定的阈值后，则执行连接检查
if (idleMillis >= timeBetweenEvictionRunsMillis
|| idleMillis < 0) {
// 若连接已不可用，则discard，重新获取新的连接
boolean validate = testConnectionInternal(poolableConnection.holder, poolableConnection.conn);
if (!validate) {
discardConnection(poolableConnection.holder);
continue;
}
}
}
}总结：当申请连接时，我们可以选择进行探活检查，对申请到的连接进行ping操作（mysql）。当然这个功能不建议开启，会对我们的业务有影响
2）validationQuery
// DruidDataSource.init
public void init() throws SQLException {
if (inited) {
return;
}
...
initFromSPIServiceLoader();
resolveDriver();
// 初始化检查会使用到validationQuery
initCheck();
...
}
protected void initCheck() throws SQLException {
if (JdbcUtils.ORACLE.equals(this.dbType)) {
isOracle = true;
...
// oracle检验
oracleValidationQueryCheck();
} else if (JdbcUtils.DB2.equals(dbType)) {
// db2校验
db2ValidationQueryCheck();
} else if (JdbcUtils.MYSQL.equals(this.dbType)
|| JdbcUtils.MYSQL_DRIVER_6.equals(this.dbType)) {
// mysql的话没有校验
isMySql = true;
}
...
}3）testOnReturn
// DruidDataSource.cecycle
protected void recycle(DruidPooledConnection pooledConnection) throws SQLException {
...
// 回收连接，即将使用完毕的连接放回连接池
if (testOnReturn) {
// 同样进行可用性测试
boolean validate = testConnectionInternal(holder, physicalConnection);
if (!validate) {
JdbcUtils.close(physicalConnection);
destroyCountUpdater.incrementAndGet(this);
lock.lock();
try {
if (holder.active) {
activeCount--;
holder.active = false;
}
closeCount++;
} finally {
lock.unlock();
}
return;
}
}
}总结：在连接获取或者连接回收时进行的探活操作，（mysql）下就是执行ping操作
4.2 获取连接超时检查
maxWait：从连接池中请求连接时，当超过maxWait后，则认为本次请求失败
// DruidDataSource.getConnection
public DruidPooledConnection getConnection(long maxWaitMillis) throws SQLException {
init();
if (filters.size() > 0) {
FilterChainImpl filterChain = new FilterChainImpl(this);
return filterChain.dataSource_connect(this, maxWaitMillis);
} else {
// 我们来分析直接获取连接的方式
return getConnectionDirect(maxWaitMillis);
}
}
// DruidDataSource.getConnectionDirect --> DruidDataSource.getConnectionInternal
private DruidPooledConnection getConnectionInternal(long maxWait) throws SQLException {
final long nanos = TimeUnit.MILLISECONDS.toNanos(maxWait);
...
// 当从连接池中获取连接时，可以选择等待maxWait，也可以选择一直等待下去
// 等待连接池的连接释放
if (maxWait > 0) {
holder = pollLast(nanos);
} else {
holder = takeLast();
}
}总结：当我们使用连接池的连接时，若所有连接均被占用，则应用需要等待maxWait，若maxWait时间内没有等待连接释放，则报错
4.3 空闲连接检查
minEvictableIdleTimeMillis：当连接池中的某个连接的空闲时间达到N毫秒后，连接池在下次检查空闲连接时，将回收该连接
timeBetweenEvictionRunsMillis：检查空闲连接的频率，单位为毫秒
keepAlive：程序没有close连接且空闲时长超过minEvictableIdleTimeMillis，则会执行validationQuery指定的SQL，以保证该程序连接不会被kill，其范围不超过minIdle指定的连接个数
源码角度分析下这三个参数：
// DruidDataSource.init()方法执行时，也会默认创建CreatorThread和DestroyThread
public void init() throws SQLException {
...
createAndLogThread();
createAndStartCreatorThread();
// 创建销毁连接线程
createAndStartDestroyThread();
}
// DruidDataSource.createAndStartDestroyThread
protected void createAndStartDestroyThread() {
// 销毁任务
destroyTask = new DestroyTask();
if (destroyScheduler != null) {
long period = timeBetweenEvictionRunsMillis;
if (period <= 0) {
period = 1000;
}
// 定时器的检查周期即为timeBetweenEvictionRunsMillis
destroySchedulerFuture = destroyScheduler.scheduleAtFixedRate(destroyTask, period, period,
TimeUnit.MILLISECONDS);
initedLatch.countDown();
return;
}
String threadName = "Druid-ConnectionPool-Destroy-" + System.identityHashCode(this);
destroyConnectionThread = new DestroyConnectionThread(threadName);
destroyConnectionThread.start();
}
// DestroyTask.java
public class DestroyTask implements Runnable {
@Override
public void run() {
//
shrink(true, keepAlive);
if (isRemoveAbandoned()) {
removeAbandoned();
}
}
}
// DruidDataSource.shrink
public void shrink(boolean checkTime, boolean keepAlive) {
for (int i = 0; i < poolingCount; ++i) {
// 若当前连接空闲时间，超过minEvictableIdleTimeMillis，则回收该连接
long idleMillis = currentTimeMillis - connection.lastActiveTimeMillis;
if (idleMillis >= minEvictableIdleTimeMillis) {
if (checkTime && i < checkCount) {
evictConnections[evictCount++] = connection;
continue;
} else if (idleMillis > maxEvictableIdleTimeMillis) {
evictConnections[evictCount++] = connection;
continue;
}
}
// 若空闲时间超过keepAliveBetweenTimeMillis，且当前支持keepAlive，则执行一次有效性检查操作
// 以更新连接的lastActiveTimeMillis，使其不被销毁
if (keepAlive && idleMillis >= keepAliveBetweenTimeMillis) {
keepAliveConnections[keepAliveCount++] = connection;
}
...
// 销毁长期空闲的连接（空闲时间大于minEvictableIdleTimeMillis）
if (evictCount > 0) {
for (int i = 0; i < evictCount; ++i) {
DruidConnectionHolder item = evictConnections[i];
Connection connection = item.getConnection();
JdbcUtils.close(connection);
destroyCountUpdater.incrementAndGet(this);
}
Arrays.fill(evictConnections, null);
}
// 对于空闲连接，执行SQL操作，更新其最新活跃时间，防止其被kill掉（空闲时间大于keepAliveBetweenTimeMillis）
for (int i = keepAliveCount - 1; i >= 0; --i) {
DruidConnectionHolder holer = keepAliveConnections[i];
Connection connection = holer.getConnection();
holer.incrementKeepAliveCheckCount();
boolean validate = false;
try {
// 探活检查
this.validateConnection(connection);
validate = true;
} catch (Throwable error) {
if (LOG.isDebugEnabled()) {
LOG.debug("keepAliveErr", error);
}
// skip
}
}
}
}总结：对于长期没被使用的连接，则在keepAlive情况下，会默认发送validationQuery指定的SQL，以更新其最后活跃时间；否则，在超过最小空闲时间后，该连接会被close掉
4.4 连接使用回收检查
removeAbandoned：要求程序从连接池中获取到连接后，N秒后必须close，否则druid会强制回收该连接
removeAbandonedTimeout：设置druid强制回收连接的时限，当程序从池中获取到连接开始算起，超过此值后，druid强制回收该连接
// 在DestroyTask.java中，
public class DestroyTask implements Runnable {
@Override
public void run() {
// 检查空闲连接
shrink(true, keepAlive);
// 回收超时连接
if (isRemoveAbandoned()) {
removeAbandoned();
}
}
}
// DruidDataSource.removeAbandoned
public int removeAbandoned() {
...
Iterator<DruidPooledConnection> iter = activeConnections.keySet().iterator();
for (; iter.hasNext();) {
DruidPooledConnection pooledConnection = iter.next();
if (pooledConnection.isRunning()) {
continue;
}
long timeMillis = (currrentNanos - pooledConnection.getConnectedTimeNano()) / (1000 * 1000);
// 连接的使用时间超过我们指定的阈值后，则直接close并丢弃
if (timeMillis >= removeAbandonedTimeoutMillis) {
iter.remove();
pooledConnection.setTraceEnable(false);
abandonedList.add(pooledConnection);
}
}
}总结：这两个参数主要为了防止，应用在获取连接执行完相应的SQL处理后忘记归还连接。
有了这连个参数，就可以强制删除未归还的连接，后续会重新创建新的连接。
总结：
此时我们就可以回答下在文章开头，我们提出的几个问题
A：Druid是如何创建连接的，有哪些必备参数
Q：Druid创建连接本质上还是通过对应的Driver（根据不同的的数据库类型）的connect方法来创建连接的，具体可见之前的mysql-java篇博客；必备参数就是常用的minIdle、maxActive等
A：连接如何被回收
Q：长时间不用的连接会被回收掉。回收是DestroyTask做的工作，并保持minIdle最小活跃连接。
A：连接的有效性如何鉴定
Q：在获取连接、归还连接、空闲时检查，都可以对连接的有效性进行检查。针对mysql而言就是执行ping命令来检查有效性。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
