Hikari源码分析

2023-10-31 14:36
文章标签 分析 源码 hikari

本文主要是介绍Hikari源码分析,希望对大家解决编程问题提供一定的参考价值,需要的开发者们随着小编来一起学习吧!

总结

连接池关系

1、HikariDataSource构建函数->生成HikariPool对象->调用HikariPool的getConection得到连接
2、HikariPool包含ConcurrentBag
3、ConcurrentBag保存连接:三个集合threadList、sharedList、handoffQueue
4、ConcurrentBag管理连接:创建连接的线程池,探活的线程池,关闭连接的线程池、阻塞队列
5、探活的线程池:调用关闭连接的线程池,调用创建链接的线程池。
6、连接Connection被包装成了poolEntry,通过poolEntryCreator->得到poolEntry->添加到shareList里面去。
7、释放链接:判断是否人等待获取链接的请求,如果有塞到handoffQueue,如果没有添加到自己线程的threadList里面去。

数据库连接池主要分为两大内容

1、连接的获取,主要涉及三个容器: threadList、sharedList、handoffQueue
2、连接池的管理:主要包含连接的创建,连接的定期检测,是否有效是否空闲,连接的关闭

在这里插入图片描述

源码分析

HikariDataSource常用的参数配置

connectionTimeou:客户端创建连接等待超时时间,如果30秒内没有获取连接则抛异常,不再继续等待
idleTimeout:连接允许最长空闲时间,如果连接空闲时间超过1分钟,则会被关闭
maxLifetime:连接最长生命周期,当连接存活时间达到30分钟之后会被关闭作退休处理
minimumIdle:连接池中最小空闲连接数
maximumPoolSize:连接池中最大连接数
validationTimeout:测试连接是否空闲的间隔
leadDetectionThreshold:连接被占用的超时时间,超过1分钟客户端没有释放连接则强制回收该连接,防止连接泄漏

1、HikariPool

Hikari中的核心类为HikariDataSource,表示Hikari连接池中的数据源,实现了DataSource接口的getConnection方法,获取链接主要是为了拿到Connection,而拿到Connection就是要通过HikariPool的实例对象来获取。

所以在HikariDataSource的构造函数里面会创建HikariPool对象。为了在调用getConnection方法时,从HikariPool里面拿到Connection

private final HikariPool fastPathPool;
private volatile HikariPool pool;public HikariDataSource(HikariConfig configuration){pool = fastPathPool = new HikariPool(this);
}/** 获取连接*/
public Connection getConnection() throws SQLException{if (fastPathPool != null) {return fastPathPool.getConnection();}pool = result = new HikariPool(this);/** 调用pool的getConnection()方法获取连接*/return result.getConnection();
}

小结:HikariDataSource->生成HikariPool对象->HikariPool对象得到Connection。

重点看HikariPool的getConnection()方法逻辑时如何得到connection

/** 获取连接*/
public Connection getConnection(final long hardTimeout) throws SQLException{/** 获取锁*/suspendResumeLock.acquire();try {do {/** 1、从ConcurrentBag中借出一个PoolEntry对象 */PoolEntry poolEntry = connectionBag.borrow(timeout, MILLISECONDS);if (poolEntry == null) {break;}/** 判断连接是否被标记为抛弃 或者 空闲时间过长, 是的话就关闭连接*/if (......) {closeConnection(poolEntry, poolEntry.isMarkedEvicted() ? EVICTED_CONNECTION_MESSAGE : DEAD_CONNECTION_MESSAGE);}/** 2、拿到poolEntry,通过Javassist创建代理连接*/return poolEntry.createProxyConnection(leakTaskFactory.schedule(poolEntry), now);} while (timeout > 0L);throw createTimeoutException(startTime);} finally {/** 释放锁*/suspendResumeLock.release();}
}

核心步骤只有两步,一个是调用ConcurrentBag的borrow方法借用一个PoolEntry对象,第二步调用调用PoolEntry的createProxyConnection方法动态生成代理connection对象。
这里涉及到了两个核心的类,分别是ConcurrentBag和PoolEntry

2、ConcurrentBag

1、PoolEntry :PoolEntry顾名思义是连接池的节点,里面有个connection属性,实际也可以看作是一个Connection对象的封装,连接池中存储的连接就是以PoolEntry的方式进行存储。

2、ConcurrentBag:ConcurrentBag本质就是连接池的主体,存储对象PoolEntry(PoolEntry主要是封装了connection),另外做了并发控制来解决连接池的并发问题。里面有锁对象,缓存PoolEntry集合,sharedList、threadList等。

/** 借出一个对象 */
public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException {/** 1.从ThreadLocal中获取当前线程绑定的对象集合 */final List<Object> list = threadList.get();/** 1.1.如果当前线程变量中存在就直接从list中返回一个*/for (int i = list.size() - 1; i >= 0; i--) {......如果bagEntry不为空。尝试将bagEntry的状态从未被使用更新成已使用。成功返回PoolEntryif (bagEntry != null && bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {return bagEntry;}}/** 2.遍历当前缓存的sharedList, 如果当前状态为未使用,则通过CAS修改为已使用*/for (T bagEntry : sharedList) {if (bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {return bagEntry;}}do {/** 3.从阻塞队列中等待超时获取元素,如果获取元素失败或者获取元素且使用成功则均返回 */final T bagEntry = handoffQueue.poll(timeout, NANOSECONDS);if (bagEntry == null || bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {return bagEntry;}} while (timeout > 10_000);//如果超时没有拿到PoolEntry,在再拿,应该有个最大超市次数。return null;
}

1、从ThreadLocal中获取或者说从threadList里面获取。注意一般存在ThreadLocal的数据都是弱引用类型。

ThreadLocal里面的PoolEntry什么时候存进去的?没有人使用时那么将连接存入ThreadLocal中,每个ThreadLocal最多会存储50个连接

2、从sharedList中获取:ThreadLocal中获取连接失败之后,会再次尝试从sharedList中获取

sharedList的PoolEntry是什么时候存进去的?
在ConcurrentBag初始化的,会初始化指定数量的PoolEntry对象存入sharedList

3、handoffQueue从阻塞队列获取

什么时候会有连接往里面塞?

其实在创建ConcurrentBag的对象的时候,他的构造函数,已经对这三个集合对象初始化,但是并没有塞数据进去。

public ConcurrentBag(...){//1、threadListif (是否为弱引用) {this.threadList = ThreadLocal.withInitial(() -> new ArrayList<>(16));} else {this.threadList = ThreadLocal.withInitial(() -> new FastList<>(IConcurrentBagEntry.class, 16));}//2、初始化sharedListthis.sharedList = new CopyOnWriteArrayList<>();//3、初始化阻塞队列handoffQueuethis.handoffQueue = new SynchronousQueue<>(true);
}

小结:borrow方法从下面三个对象中获取

1、threadList
2、sharedList    
3、handoffQueue  指定超时时间,没有拿到结束请求。

3、管理【连接池】

HikariPool内部属性包含了ConcurrentBag对象,在HikariPool初始化时会创建ConcurrentBag对象,所以ConcurrentBag的构造函数是在HikariPool初始化时调用,HikariPool构造函数如下:

public HikariPool(final HikariConfig config) {//1、初始化ConcurrentBag对象this.connectionBag = new ConcurrentBag<>(this);/** 2、【创建连接】的线程池*/this.addConnectionExecutor = createThreadPoolExecutor(addQueue, poolName + " connection adder", threadFactory, new ThreadPoolExecutor.DiscardPolicy());/** 3、【探活】的线程池,通过定时检测,保持固定数量的"有效连接", 怎么的Connection属于有效? */this.houseKeepingExecutorService = initializeHouseKeepingExecutorService();this.leakTaskFactory = new ProxyLeakTaskFactory(config.getLeakDetectionThreshold(), houseKeepingExecutorService);/**【保持连接池连接数量】的任务,通过【探活】线程池来执行的,执行任务【HouseKeeper】,houseKeeperTask只是执行的返回结果,重点在于提交的任务类【HouseKeeper】 */this.houseKeeperTask = houseKeepingExecutorService.scheduleWithFixedDelay(new HouseKeeper(), 100L, housekeepingPeriodMs, MILLISECONDS);/** 4、【关闭连接】的线程池 */this.closeConnectionExecutor = createThreadPoolExecutor(config.getMaximumPoolSize(), "xx", threadFactory, new ThreadPoolExecutor.CallerRunsPolicy());/** 5、【阻塞队列】根据配置的最大连接数, 当连接数不够时,需要获取链接的线程就在这里等待 */LinkedBlockingQueue<Runnable> addQueue = new LinkedBlockingQueue<>(config.getMaximumPoolSize());this.addConnectionQueue = unmodifiableCollection(addQueue);   
}

这里有一个定时任务houseKeeperTask,该定时任务的作用是定时检测【连接池中的连接】,保持连接池中的【连接数】稳定在一个固定的值,执行的内容就是HouseKeep的run方法

private final class HouseKeeper implements Runnable {@Overridepublic void run(){/** 关闭连接池中需要【被丢弃】的连接,每个链接有个【最大生命周期】,超过这个周期都视为被丢弃的连接 */if (plusMillis(now, 128) < plusMillis(previous, housekeepingPeriodMs)) {softEvictConnections();return;}/** 获取当前连接池中【不是使用中】的连接集合 */            final List<PoolEntry> notInUse = connectionBag.values(STATE_NOT_IN_USE);int toRemove = notInUse.size() - config.getMinimumIdle();for (PoolEntry entry : notInUse) {/** 当前空闲的连接如果超过【最大空闲时间idleTimeout】则关闭空闲连接 */if (toRemove > 0 && elapsedMillis(entry.lastAccessed, now) > idleTimeout && connectionBag.reserve(entry)) {closeConnection(entry, "(connection has passed idleTimeout)");toRemove--;}}/** 填充连接池,保持连接池数量至少保持【minimum个连接】数量 */fillPool(); // Try to maintain minimum connections}
}

最大生命周期和空闲时间是2个概念。

该定时任务主要是为了维护连接池中连接的数量,首先需要将被标记为需要丢弃的连接进行关闭,然后将空闲超时的连接进行关闭,最后当连接池中的连接少于最小值时就需要对连接池进行补充连接的操作。所以在初始化连接池时,初始化连接的操作就是在fillPool方法中实现的。fillPool方法源码如下:

/** 填充连接池 */
private synchronized void fillPool() {//计算需要添加的连接数量final int connectionsToAdd = Math.min(config.getMaximumPoolSize() - getTotalConnections(), config.getMinimumIdle() - getIdleConnections())- addConnectionQueue.size();for (int i = 0; i < connectionsToAdd; i++) {/** 向【创建连接】的线程池,提交创建连接的任务 */addConnectionExecutor.submit(poolEntryCreator);}
}

先计算需要创建的连接数量,向创建连接的线程池中提交任务 poolEntryCreator,PoolEntryCreator创建PoolEntry对象的逻辑如下:

/** 创建PoolEntry对象线程 */

private final class PoolEntryCreator implements Callable<Boolean> {@Overridepublic Boolean call() {/** 1.当前连接池状态正常并且需求创建连接时 */while (poolState == POOL_NORMAL && shouldCreateAnotherConnection()) {/** 2.创建PoolEntry对象 */final PoolEntry poolEntry = createPoolEntry();if (poolEntry != null) {/** 3.将PoolEntry对象添加到ConcurrentBag对象中的sharedList中 */connectionBag.add(poolEntry);return Boolean.TRUE;}/** 如果创建失败,睡眠指定时间,回到循环在尝试创建 */quietlySleep(sleepBackoff);}return Boolean.FALSE;}
}

createPoolEntry方法逻辑如下:

/** 创建PoolEntry对象 */
private PoolEntry createPoolEntry() {/** 1.初始化PoolEntry对象,newPoolEntry里面会先创建Connection对象,PoolEntry再把Connection封装一下返回 */final PoolEntry poolEntry = newPoolEntry();/** 获取连接最大生命周期时长 */final long maxLifetime = config.getMaxLifetime();if (maxLifetime > 0) {/** 2.给PoolEntry添加定时任务,当PoolEntry对象达到最大生命周期时间后触发定时任务将连接标记为被抛弃 */poolEntry.setFutureEol(houseKeepingExecutorService.schedule(() -> {/** 判断刚创建的连接poolEntry,是否达到最大生命周期,如果满足则抛弃连接 */if (softEvictConnection(poolEntry, "xx", false)) {/** 丢弃一个连接之后,调用addBagItem补充新的PoolEntry对象 */addBagItem(connectionBag.getWaitingThreadCount());}}, lifetime, MILLISECONDS));}return poolEntry;
}PoolEntry newPoolEntry() throws Exception{return new PoolEntry(newConnection(), this, isReadOnly, isAutoCommit);
}

首先创建一个新的PoolEntry对象,PoolEntry构造时会创建Connection对象,另外如果连接设置了最大生命周期时长,那么需要给每个PoolEntry添加定时任务,为了防止多个PoolEntry同时创建同时被关闭,所以每个PoolEntry的最大生命周期时间都不一样。当PoolEntry达到最大生命周期后会触发softEvictConnection方法,将PoolEntry标记为需要被丢弃,另外由于抛弃了PoolEntry对象,所以需要重新调用addBagItem方法对PoolEntry对象进行补充。

上面会调用addBagItem方法,我们看下addBagItem的做了什么?

public void addBagItem(final int waiting) {/** 判断是否需要创建连接 */final boolean shouldAdd = waiting - addConnectionQueue.size() >= 0; // Yes, >= is intentional.if (shouldAdd) {/** 向创建连接线程池中提交创建连接的任务 */addConnectionExecutor.submit(poolEntryCreator);}
}

总结:

从ConcurrentBag中获取连接一共分成三步,首先从当前线程的ThreadLocal中获取,如果有直接返回一个连接,如果ThreadLocal中没有则从sharedList中获取,sharedList可以理解为ConcurrentBag缓存的连接池,每当创建了一个PoolEntry对象之后都会添加到sharedList中去,如果sharedList中的连接状态都不是可用状态,此时就需要通过IBagStateListener提交一个创建连接的任务,交给创建连接的线程池去执行,创建新的连接。

新的连接创建成功之后会将PoolEntry对象添加到无容量的阻塞队列handoffQueue中,当请求线程进来,如果ThreadLocal和sharedList都没有拿到,就不断尝试从handoffQueue队列中获取连接直到成功获取或者超时返回。

HikariPool包含->ConcurrentBag->包含threadList、sharedList、handoffQueue

释放连接

当客户端释放连接时会调用collection的close方法,Hikari中的Connection使用的是代理连接ProxyConnection对象,调用close方法时会调用关联的PoolEntry对象的回收方法recycle方法,PoolEntry的recycle方法源码如下,主要还是通过hikariPool拿到connectionBag,嗲用connectionBag的requite方法。

void recycle(final long lastAccessed) {if (connection != null) {hikariPool.recycle(this);}
}
/** 调用HikariPool的recycle方法,回收当前PoolEntry对象 */
void recycle(final PoolEntry poolEntry) {/** 调用ConcurrentBag的回收方法 */connectionBag.requite(poolEntry);
}/** 回收元素方法 */
public void requite(final T bagEntry) {/** 1.设置状态为未使用 */bagEntry.setState(STATE_NOT_IN_USE);/** 2.如果当前存在等待线程,则优先将元素给等待线程 */for (int i = 0; waiters.get() > 0; i++) {/** 2.1.将元素添加到无界阻塞队列中,等待其他线程获取 */if (bagEntry.getState() != STATE_NOT_IN_USE || handoffQueue.offer(bagEntry)) {return;} else {/** 当前线程不再继续执行,让出CPU执行权 */yield();}}/** 3.如果当前连接没有被其他线程使用,则添加到当前线程的ThreadLocal中,当这个线程再次执行DB操作时,会优先从ThreadLocal里面拿 */final List<Object> threadLocalList = threadList.get();if (threadLocalList.size() < 50) {threadLocalList.add(weakThreadLocals ? new WeakReference<>(bagEntry) : bagEntry);}
}

回收连接最终会调用ConcurrentBag的requite方法,方法逻辑不复杂,首先将PoolEntry元素状态设置为未使用,然后判断当前是否存在等待连接的线程,如果存在则将连接加入到无界阻塞队列中去,由等待连接的线程从阻塞队列中去获取;

如果当前没有等待连接的线程,则将连接添加到本地线程变量ThreadLocal中,等待当前线程下次获取连接时直接从ThreadLocal中获取。

源码分析:跳转

这篇关于Hikari源码分析的文章就介绍到这儿,希望我们推荐的文章对编程师们有所帮助!



http://www.chinasem.cn/article/316045

相关文章

Python实现无痛修改第三方库源码的方法详解

《Python实现无痛修改第三方库源码的方法详解》很多时候,我们下载的第三方库是不会有需求不满足的情况,但也有极少的情况,第三方库没有兼顾到需求,本文将介绍几个修改源码的操作,大家可以根据需求进行选择... 目录需求不符合模拟示例 1. 修改源文件2. 继承修改3. 猴子补丁4. 追踪局部变量需求不符合很

Spring事务中@Transactional注解不生效的原因分析与解决

《Spring事务中@Transactional注解不生效的原因分析与解决》在Spring框架中,@Transactional注解是管理数据库事务的核心方式,本文将深入分析事务自调用的底层原理,解释为... 目录1. 引言2. 事务自调用问题重现2.1 示例代码2.2 问题现象3. 为什么事务自调用会失效3

找不到Anaconda prompt终端的原因分析及解决方案

《找不到Anacondaprompt终端的原因分析及解决方案》因为anaconda还没有初始化,在安装anaconda的过程中,有一行是否要添加anaconda到菜单目录中,由于没有勾选,导致没有菜... 目录问题原因问http://www.chinasem.cn题解决安装了 Anaconda 却找不到 An

Spring定时任务只执行一次的原因分析与解决方案

《Spring定时任务只执行一次的原因分析与解决方案》在使用Spring的@Scheduled定时任务时,你是否遇到过任务只执行一次,后续不再触发的情况?这种情况可能由多种原因导致,如未启用调度、线程... 目录1. 问题背景2. Spring定时任务的基本用法3. 为什么定时任务只执行一次?3.1 未启用

C++ 各种map特点对比分析

《C++各种map特点对比分析》文章比较了C++中不同类型的map(如std::map,std::unordered_map,std::multimap,std::unordered_multima... 目录特点比较C++ 示例代码 ​​​​​​代码解释特点比较1. std::map底层实现:基于红黑

Spring、Spring Boot、Spring Cloud 的区别与联系分析

《Spring、SpringBoot、SpringCloud的区别与联系分析》Spring、SpringBoot和SpringCloud是Java开发中常用的框架,分别针对企业级应用开发、快速开... 目录1. Spring 框架2. Spring Boot3. Spring Cloud总结1. Sprin

Spring 中 BeanFactoryPostProcessor 的作用和示例源码分析

《Spring中BeanFactoryPostProcessor的作用和示例源码分析》Spring的BeanFactoryPostProcessor是容器初始化的扩展接口,允许在Bean实例化前... 目录一、概览1. 核心定位2. 核心功能详解3. 关键特性二、Spring 内置的 BeanFactory

MyBatis-Plus中Service接口的lambdaUpdate用法及实例分析

《MyBatis-Plus中Service接口的lambdaUpdate用法及实例分析》本文将详细讲解MyBatis-Plus中的lambdaUpdate用法,并提供丰富的案例来帮助读者更好地理解和应... 目录深入探索MyBATis-Plus中Service接口的lambdaUpdate用法及示例案例背景

MyBatis-Plus中静态工具Db的多种用法及实例分析

《MyBatis-Plus中静态工具Db的多种用法及实例分析》本文将详细讲解MyBatis-Plus中静态工具Db的各种用法,并结合具体案例进行演示和说明,具有很好的参考价值,希望对大家有所帮助,如有... 目录MyBATis-Plus中静态工具Db的多种用法及实例案例背景使用静态工具Db进行数据库操作插入

Go使用pprof进行CPU,内存和阻塞情况分析

《Go使用pprof进行CPU,内存和阻塞情况分析》Go语言提供了强大的pprof工具,用于分析CPU、内存、Goroutine阻塞等性能问题,帮助开发者优化程序,提高运行效率,下面我们就来深入了解下... 目录1. pprof 介绍2. 快速上手:启用 pprof3. CPU Profiling:分析 C