Druid 连接池源码阅读 08

    public void shrink(boolean checkTime, boolean keepAlive) {        try {            lock.lockInterruptibly();        } catch (InterruptedException e) {            return;        }
        boolean needFill = false;        int evictCount = 0;        int keepAliveCount = 0;        int fatalErrorIncrement = fatalErrorCount - fatalErrorCountLastShrink;        fatalErrorCountLastShrink = fatalErrorCount;                try {            if (!inited) {                return;            }//数据库连接池中存储的连接池总数减去最小空闲连接数            final int checkCount = poolingCount - minIdle;            final long currentTimeMillis = System.currentTimeMillis();            for (int i = 0; i < poolingCount; ++i) {              //从连接池中取出一个连接                DruidConnectionHolder connection = connections[i];							//如果有致命错误或致命错误增量大于0 并且最后致命错误的时间大于当前连接的连接时间，则把连接添加到keepAliveConnections数组，退出本次循环                if ((onFatalError || fatalErrorIncrement > 0) && (lastFatalErrorTimeMillis > connection.connectTimeMillis))  {                    keepAliveConnections[keepAliveCount++] = connection;                    continue;                }
                if (checkTime) {                    if (phyTimeoutMillis > 0) {                        long phyConnectTimeMillis = currentTimeMillis - connection.connectTimeMillis;                        if (phyConnectTimeMillis > phyTimeoutMillis) {                            evictConnections[evictCount++] = connection;                            continue;                        }                    }
                    long idleMillis = currentTimeMillis - connection.lastActiveTimeMillis;
                    if (idleMillis < minEvictableIdleTimeMillis                            && idleMillis < keepAliveBetweenTimeMillis                    ) {                        break;                    }
                    if (idleMillis >= minEvictableIdleTimeMillis) {                        if (checkTime && i < checkCount) {                            evictConnections[evictCount++] = connection;                            continue;                        } else if (idleMillis > maxEvictableIdleTimeMillis) {                            evictConnections[evictCount++] = connection;                            continue;                        }                    }
                    if (keepAlive && idleMillis >= keepAliveBetweenTimeMillis) {                        keepAliveConnections[keepAliveCount++] = connection;                    }                } else {                    if (i < checkCount) {                        evictConnections[evictCount++] = connection;                    } else {                        break;                    }                }            }
            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;            }        } finally {            lock.unlock();        }
        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);        }
        if (keepAliveCount > 0) {            // keep order            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                }
                boolean discard = !validate;                if (validate) {                    holer.lastKeepTimeMillis = System.currentTimeMillis();                    boolean putOk = put(holer, 0L, true);                    if (!putOk) {                        discard = true;                    }                }
                if (discard) {                    try {                        connection.close();                    } catch (Exception e) {                        // skip                    }
                    lock.lock();                    try {                        discardCount++;
                        if (activeCount + poolingCount <= minIdle) {                            emptySignal();                        }                    } finally {                        lock.unlock();                    }                }            }            this.getDataSourceStat().addKeepAliveCheckCount(keepAliveCount);            Arrays.fill(keepAliveConnections, null);        }
        if (needFill) {            lock.lock();            try {                int fillCount = minIdle - (activeCount + poolingCount + createTaskCount);                for (int i = 0; i < fillCount; ++i) {                    emptySignal();                }            } finally {                lock.unlock();            }        } else if (onFatalError || fatalErrorIncrement > 0) {            lock.lock();            try {                emptySignal();            } finally {                lock.unlock();            }        }    }