druid return行为方法源码示例解析

更新时间：2023年09月26日 09:21:17 作者：codecraft

这篇文章主要为大家介绍了druid return行为源码示例解析,有需要的朋友可以借鉴参考下,希望能够有所帮助,祝大家多多进步,早日升职加薪

序

本文主要研究一下druid的return行为

close

com/alibaba/druid/pool/DruidPooledConnection.java

@Override
    public void close() throws SQLException {
        if (this.disable) {
            return;
        }
        DruidConnectionHolder holder = this.holder;
        if (holder == null) {
            if (dupCloseLogEnable) {
                LOG.error("dup close");
            }
            return;
        }
        DruidAbstractDataSource dataSource = holder.getDataSource();
        boolean isSameThread = this.getOwnerThread() == Thread.currentThread();
        if (!isSameThread) {
            dataSource.setAsyncCloseConnectionEnable(true);
        }
        if (dataSource.isAsyncCloseConnectionEnable()) {
            syncClose();
            return;
        }
        if (!CLOSING_UPDATER.compareAndSet(this, 0, 1)) {
            return;
        }
        try {
            for (ConnectionEventListener listener : holder.getConnectionEventListeners()) {
                listener.connectionClosed(new ConnectionEvent(this));
            }
            List<Filter> filters = dataSource.getProxyFilters();
            if (filters.size() > 0) {
                FilterChainImpl filterChain = new FilterChainImpl(dataSource);
                filterChain.dataSource_recycle(this);
            } else {
                recycle();
            }
        } finally {
            CLOSING_UPDATER.set(this, 0);
        }
        this.disable = true;
    }

close方法先从holder获取当前的dataSource，然后判断ownerThread，若不是同一个线程则设置asyncCloseConnectionEnable为true，若asyncCloseConnectionEnable为true则执行syncClose(这里语义貌似相反)，否则执行recycle方法

syncClose

com/alibaba/druid/pool/DruidPooledConnection.java

public void syncClose() throws SQLException {
        lock.lock();
        try {
            if (this.disable || CLOSING_UPDATER.get(this) != 0) {
                return;
            }
            DruidConnectionHolder holder = this.holder;
            if (holder == null) {
                if (dupCloseLogEnable) {
                    LOG.error("dup close");
                }
                return;
            }
            if (!CLOSING_UPDATER.compareAndSet(this, 0, 1)) {
                return;
            }
            for (ConnectionEventListener listener : holder.getConnectionEventListeners()) {
                listener.connectionClosed(new ConnectionEvent(this));
            }
            DruidAbstractDataSource dataSource = holder.getDataSource();
            List<Filter> filters = dataSource.getProxyFilters();
            if (filters.size() > 0) {
                FilterChainImpl filterChain = new FilterChainImpl(dataSource);
                filterChain.dataSource_recycle(this);
            } else {
                recycle();
            }
            this.disable = true;
        } finally {
            CLOSING_UPDATER.set(this, 0);
            lock.unlock();
        }
    }

syncClose方法主要是加锁执行recycle

recycle

public void recycle() throws SQLException {
        if (this.disable) {
            return;
        }
        DruidConnectionHolder holder = this.holder;
        if (holder == null) {
            if (dupCloseLogEnable) {
                LOG.error("dup close");
            }
            return;
        }
        if (!this.abandoned) {
            DruidAbstractDataSource dataSource = holder.getDataSource();
            dataSource.recycle(this);
        }
        this.holder = null;
        conn = null;
        transactionInfo = null;
        closed = true;
    }

recycle方法主要是执行dataSource.recycle(this)

DruidDataSource.recycle

com/alibaba/druid/pool/DruidDataSource.java

protected void recycle(DruidPooledConnection pooledConnection) throws SQLException {
        final DruidConnectionHolder holder = pooledConnection.holder;
        if (holder == null) {
            LOG.warn("connectionHolder is null");
            return;
        }
        if (logDifferentThread //
                && (!isAsyncCloseConnectionEnable()) //
                && pooledConnection.ownerThread != Thread.currentThread()//
        ) {
            LOG.warn("get/close not same thread");
        }
        final Connection physicalConnection = holder.conn;
        if (pooledConnection.traceEnable) {
            Object oldInfo = null;
            activeConnectionLock.lock();
            try {
                if (pooledConnection.traceEnable) {
                    oldInfo = activeConnections.remove(pooledConnection);
                    pooledConnection.traceEnable = false;
                }
            } finally {
                activeConnectionLock.unlock();
            }
            if (oldInfo == null) {
                if (LOG.isWarnEnabled()) {
                    LOG.warn("remove abandonded failed. activeConnections.size " + activeConnections.size());
                }
            }
        }
        final boolean isAutoCommit = holder.underlyingAutoCommit;
        final boolean isReadOnly = holder.underlyingReadOnly;
        final boolean testOnReturn = this.testOnReturn;
        try {
            // check need to rollback?
            if ((!isAutoCommit) && (!isReadOnly)) {
                pooledConnection.rollback();
            }
            // reset holder, restore default settings, clear warnings
            boolean isSameThread = pooledConnection.ownerThread == Thread.currentThread();
            if (!isSameThread) {
                final ReentrantLock lock = pooledConnection.lock;
                lock.lock();
                try {
                    holder.reset();
                } finally {
                    lock.unlock();
                }
            } else {
                holder.reset();
            }
            if (holder.discard) {
                return;
            }
            if (phyMaxUseCount > 0 && holder.useCount >= phyMaxUseCount) {
                discardConnection(holder);
                return;
            }
            if (physicalConnection.isClosed()) {
                lock.lock();
                try {
                    if (holder.active) {
                        activeCount--;
                        holder.active = false;
                    }
                    closeCount++;
                } finally {
                    lock.unlock();
                }
                return;
            }
            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;
                }
            }
            if (holder.initSchema != null) {
                holder.conn.setSchema(holder.initSchema);
                holder.initSchema = null;
            }
            if (!enable) {
                discardConnection(holder);
                return;
            }
            boolean result;
            final long currentTimeMillis = System.currentTimeMillis();
            if (phyTimeoutMillis > 0) {
                long phyConnectTimeMillis = currentTimeMillis - holder.connectTimeMillis;
                if (phyConnectTimeMillis > phyTimeoutMillis) {
                    discardConnection(holder);
                    return;
                }
            }
            lock.lock();
            try {
                if (holder.active) {
                    activeCount--;
                    holder.active = false;
                }
                closeCount++;
                result = putLast(holder, currentTimeMillis);
                recycleCount++;
            } finally {
                lock.unlock();
            }
            if (!result) {
                JdbcUtils.close(holder.conn);
                LOG.info("connection recyle failed.");
            }
        } catch (Throwable e) {
            holder.clearStatementCache();
            if (!holder.discard) {
                discardConnection(holder);
                holder.discard = true;
            }
            LOG.error("recyle error", e);
            recycleErrorCountUpdater.incrementAndGet(this);
        }
    }
    boolean putLast(DruidConnectionHolder e, long lastActiveTimeMillis) {
        if (poolingCount >= maxActive || e.discard || this.closed) {
            return false;
        }
        e.lastActiveTimeMillis = lastActiveTimeMillis;
        connections[poolingCount] = e;
        incrementPoolingCount();
        if (poolingCount > poolingPeak) {
            poolingPeak = poolingCount;
            poolingPeakTime = lastActiveTimeMillis;
        }
        notEmpty.signal();
        notEmptySignalCount++;
        return true;
    }

recycle方法先执行DruidConnectionHolder的reset方法，之后针对大于等于phyMaxUseCount的场景执行discardConnection；针对testOnReturn为true，则执行testConnectionInternal校验，校验失败则关闭连接；最后加锁执行putLast把连接放回连接池，若归还失败则关闭连接。

小结

close方法先从holder获取当前的dataSource，然后判断ownerThread，若不是同一个线程则设置asyncCloseConnectionEnable为true，若asyncCloseConnectionEnable为true则执行syncClose(这里语义貌似相反)，否则执行recycle方法。

以上就是druid return行为源码示例解析的详细内容，更多关于druid return行为的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

servlet重定向详解（八）
这篇文章主要为大家详细介绍了servlet重定向的相关资料，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2017-09-09
java实现模拟RPG格斗
这篇文章主要介绍了java实现模拟RPG格斗，每个英雄具有以下几个属性：生命值（为0时英雄倒下）、攻击力（每次攻击时扣除对方的生命值点数）、攻击间隔（每次攻击过后都要等待间隔时间才能进行下次攻击首次攻击之前也要先等待间隔时间）简单设置了下吧，小伙伴可以参考下
2015-03-03
Java通过JavaMail发送邮件功能
这篇文章主要为大家详细介绍了Java通过JavaMail发送邮件功能，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
2022-08-08
SpringBoot常见问题小结
这篇文章主要介绍了SpringBoot常见问题小结,需要的朋友可以参考下
2017-07-07
用java实现冒泡排序算法
两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止
2013-01-01
Spring中bean标签的用法详解
Bean标签一般用于配置对象交由Spring 来创建，这篇文章主要来和大家详细聊聊Spring中bean标签的用法，感兴趣的小伙伴可以跟随小编一起学习一下
2023-06-06
Spring Boot使用RestTemplate消费REST服务的几个问题记录
这篇文章主要介绍了Spring Boot使用RestTemplate消费REST服务的几个问题记录，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2018-06-06
SpringBoot中获取微信用户信息的方法
这篇文章主要介绍了SpringBoot中获取微信用户信息的方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
2019-09-09
Java 响应式编程之Spring WebFlux+Reactor 实战攻略
本文详细介绍了Java响应式编程的核心概念,重点讲解了SpringWebFlux框架与Reactor响应式库的实战用法,通过大量可运行的示例代码,帮助读者快速上手并理解响应式编程的精髓,本文结合实例代码给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧
2025-12-12
Java中哈希在算法中的10大经典用法
Java中的哈希表,也称为散列表,是一种高效的数据存储结构,它利用了哈希函数将键（Key）映射到存储位置,从而实现快速访问,这篇文章主要介绍了Java中哈希的相关资料,文中通过代码介绍的非常详细,需要的朋友可以参考下
2026-05-05

druid return行为方法源码示例解析

目录

序

close

syncClose

recycle

DruidDataSource.recycle

小结

相关文章

最新评论

大家感兴趣的内容

最近更新的内容

常用在线小工具