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中获取。

源码分析：跳转

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/157464.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Web前端自动化测试Cypress实践总结

Web前端自动化测试Cypress实践总结

本文主要首先主要介绍了什么是自动化测试&#xff0c;接着对常用的自动化测试框架进行了对比分析&#xff0c;最后&#xff0c;介绍了如果将自动化测试框架Cypress运用在项目中。 一、自动化测试概述 为了保障软件质量&#xff0c;并减少重复性的测试工作&#xff0c;自动化测…
阅读更多...
[架构之路-251/创业之路-82]：目标系统 - 纵向分层 - 企业信息化的呈现形态：常见企业信息化软件系统 - 商业智能、决策支持系统、知识管理

[架构之路-251/创业之路-82]：目标系统 - 纵向分层 - 企业信息化的呈现形态：常见企业信息化软件系统 - 商业智能、决策支持系统、知识管理

目录 前言&#xff1a; 一、企业信息化的结果&#xff1a;常见企业信息化软件 1.1 商业智能 - 管理层 1.1.1 什么是商业智能What 1.1.1.1 商业智能常见工具 1.1.2 为什么需要商业智能Why&#xff1f; 1.1.3 谁需要商业智能who&#xff1f; 1.1.4 商业智能在企业管理中的…
阅读更多...
基于深度学习的植物识别算法 - cnn opencv python 计算机竞赛

基于深度学习的植物识别算法 - cnn opencv python 计算机竞赛

文章目录 0 前言1 课题背景2 具体实现3 数据收集和处理3 MobileNetV2网络4 损失函数softmax 交叉熵4.1 softmax函数4.2 交叉熵损失函数 5 优化器SGD6 最后 0 前言 &#x1f525; 优质竞赛项目系列&#xff0c;今天要分享的是 &#x1f6a9; **基于深度学习的植物识别算法 ** …
阅读更多...
c++ Vector 学习

c++ Vector 学习

vevtor 是c 中自带得动态数组&#xff0c;dynamic array array can hold different values/objects of same type 可以装不同得类型或者对象 dynamic size can be changed at runtime 可以运行得时候改变 要使用的话&#xff0c;先引入 #include <vector> std::vector…
阅读更多...
Linux0.11内核源码解析-malloc

Linux0.11内核源码解析-malloc

malloc介绍 Linux内核版本0.11中的malloc.c文件实现了内存分配的功能。在这个版本的Linux内核中&#xff0c;malloc.c文件包含了内核级别的内存分配函数&#xff0c;用于分配和释放内核中的内存。这些函数可以帮助内核管理可用的内存&#xff0c;并允许内核动态地分配和释放内…
阅读更多...
html用css grid实现自适应四宫格放视频

html用css grid实现自适应四宫格放视频

想同时播放四个本地视频&#xff1a; 四宫格&#xff1b;自式应&#xff0c;即放缩浏览器时&#xff0c;四宫格也跟着放缩&#xff1b;尽量填满页面&#xff08;F11 浏览器全屏时可以填满整个屏幕&#xff09;。 在 html 中放视频用 video 标签&#xff0c;参考 [1]&#xff1…
阅读更多...
Tomcat运行日志乱码问题/项目用tomcat启动时窗口日志乱码

Tomcat运行日志乱码问题/项目用tomcat启动时窗口日志乱码

文章目录 一、问题描述&#xff1a;二、产生原因三、解决方法 一、问题描述&#xff1a; 项目在idea中运行时日志是正常的&#xff0c;用Tomcat启动时发现一大堆看不懂的文字&#xff0c;如 二、产生原因 产生乱码的根本原因就是编码和解码不一致&#xff0c;举个例子就是翻…
阅读更多...
Linux 环境下 安装 Elasticsearch 7.13.2

Linux 环境下 安装 Elasticsearch 7.13.2

Linux 环境下 安装 Elasticsearch 7.13.2 前言镜像下载&#xff08;国内镜像地址&#xff09;解压安装包修改配置文件用 Es 自带Jdk 运行配置 Es 可被远程访问然后启动接着启动本地测试一下能不能连 Es 前言 借公司的 centos 7 服务器&#xff0c;搭建一个 Es&#xff0c;正好熟…
阅读更多...
双目视觉检测 KX02-SY1000型测宽仪 有效修正和消除距离变化对测量的影响

双目视觉检测 KX02-SY1000型测宽仪 有效修正和消除距离变化对测量的影响

双目视觉检测的基本原理 利用相机测量宽度时&#xff0c;由于单个相机在成像时存在“近大远小”的现象&#xff0c;并且单靠摄入的图像无法知道被测物的距离&#xff0c;所以由被测物的跳动导致的被测物到工业相机之间距离变化&#xff0c;使测量精度难以提高。 因此测宽仪需…
阅读更多...
新手教程｜搭建zkLogin的证明服务端

新手教程｜搭建zkLogin的证明服务端

zkLogin是Sui的一种原生功能&#xff0c;它允许人们只使用来自如Google、Meta和Twitch等的现有网络凭证来创建Sui地址并签署交易。为确保隐私&#xff0c;集成zkLogin的apps必须创建ZKP (Zero Knowledge proofs&#xff0c;零知识证明)&#xff0c;以使凭证对app保持隐藏&#…
阅读更多...
性能测试实例

性能测试实例

上一篇博文主要通过两个例子让测试新手了解一下测试思想&#xff0c;和在做测试之前应该了解人几点&#xff0c;那么我们在如何完成一次完整的性能测试呢&#xff1f; 测试报告是一次完整性能测试的体现&#xff0c;所以&#xff0c;这里我给出一个完整的性能测试报告&#xff…
阅读更多...
关于pyinstaller执行报错的解决方案

关于pyinstaller执行报错的解决方案

已经安装好了pyinstaller&#xff0c;但是在终端执行时报错&#xff1a; pyinstaller : 无法将“pyinstaller”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。请检查名称的拼写&#xff0c;如果包括路径&#xff0c;请确保路径正确&#xff0c;然后再试一次。 所在位置…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023