引言
Springboot 2.0将 HikariCP 作为默认数据库连接池这一事件之后,HikariCP 作为一个后起之秀出现在大众的视野中。HikariCP 是在日本的程序员开源的,hikari日语意思为“光”,HikariCP 也以速度快的特点受到越来越多人的青睐。
今天就让我们来探讨一下HikariCP为什么这么快?
连接池技术
我们平常编码过程中,经常会碰到线程池啊,数据库连接池啊等等,那么这个池到底是一门怎样的技术呢?
简单来说,连接池是一个创建和管理连接的缓冲池技术。连接池主要由三部分组成:连接池的建立、连接池中连接的使用管理、连接池的关闭。连接池技术的核心思想是:连接复用,通过建立一个数据库连接池以及一套连接使用、分配、管理策略,使得该连接池中的连接可以得到高效、安全的复用。它不仅仅只限于管理数据库访问连接,也可以管理其他连接资源。
HakariCP
HakariCP 项目的 README 中的一段话。
Fast, simple, reliable. HikariCP is a "zero-overhead" production ready JDBC connection pool. At roughly 130Kb, the library is very light.
快速、简单、可靠。HikariCP是一个“零开销”的生产就绪JDBC连接池。这个库大约有130Kb,非常轻。
这个介绍真是简洁但“全面”。搭配上下边这张图。
看到这些数据,再加上Springboot 2.0 将 HikariCP 作为默认数据库连接池这件事,我已经十分好奇 HikariCP 的实现原理了。
HikariCP为什么这么快?
-
两个HikariPool:定义了两个HikariPool对象,一个采用final类型定义,避免在获取连接时才初始化,提高性能,也避免
volatile
的额外开销。 -
FastList替代ArrayList:采用自定义的FastList替代了ArrayList,FastList的get方法去除了范围检查逻辑,并且remove方法是从尾部开始扫描的,而并不是从头部开始扫描的。因为Connection的打开和关闭顺序通常是相反的。
-
更快的并发集合实现:使用自定义ConcurrentBag,性能更优。
-
更快的获取连接:同一个线程获取数据库连接时从ThreadLocal中获取,没有并发操作。
-
精简字节码:HikariCP利用了一个第三方的Java字节码修改类库Javassist来生成委托实现动态代理,速度更快,相比于JDK 代理生成的字节码更少。
HikariCP原理
我们通过分析源码来看 HikariCP 是如何这么快的。先来看一下 HikariCP 的简单使用。
maven依赖:
<dependency>
<groupId>com.zaxxer</groupId>
<artifactId>HikariCP</artifactId>
<version>4.0.3</version>
</dependency>
@Test
public void testHikariCP() throws SQLException {
HikariConfig hikariConfig = new HikariConfig();
hikariConfig.setJdbcUrl("jdbc:mysql://127.0.0.1:3306/iam?characterEncoding=utf8");
hikariConfig.setUsername("root");
hikariConfig.setPassword("123456");
hikariConfig.setPoolName("testHikari");
hikariConfig.setMinimumIdle(4);
hikariConfig.setMaximumPoolSize(8);
hikariConfig.setIdleTimeout(600000L);
hikariConfig.setConnectionTimeout(10000L);
HikariDataSource dataSource = new HikariDataSource(hikariConfig);
Connection connection = dataSource.getConnection();
Statement statement = connection.createStatement();
ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) AS countNum tt_user");
if (resultSet.next()) {
System.out.println("countNum结果为:" + resultSet.getInt("countNum"));
}
resultSet.close();
statement.close();
connection.close();
dataSource.close();
}
HikariConfig:可以设置一些数据库基本配置信息和一些连接池的配置信息。
HikariDataSource:实现了 DataSource,DataSource是一个数据源标准或者说规范,Java所有连接池需要基于这个规范进行实现。
我们就从 HikariDataSource 开始说起。HikariDataSource有两个构造方法HikariDataSource()
和HikariDataSource(HikariConfig configuration)
。
private final HikariPool fastPathPool;
private volatile HikariPool pool;
public HikariDataSource()
{
super();
fastPathPool = null;
}
public HikariDataSource(HikariConfig configuration)
{
configuration.validate();
configuration.copyStateTo(this);
LOGGER.info("{} - Starting...", configuration.getPoolName());
pool = fastPathPool = new HikariPool(this);
LOGGER.info("{} - Start completed.", configuration.getPoolName());
this.seal();
}
HikariPool为什么要有两个(fastPathPool和pool)呢?
可以看到无参构造方法fastPathPool是null,有参构造pool = fastPathPool,采用无参构造在getConnection()
时候才会初始化(下边会详细讲解),性能略低,并且pool是volatile
关键字修饰,会有一些额外开销。所以建议使用有参构造。这也是HikariPool快的原因之一。
有参构造里有一行new HikariPool(this)
,我们来看一下怎么个事。
代码太多了,往后只贴关键代码了。。。
public HikariPool(final HikariConfig config)
{
super(config);
this.connectionBag = new ConcurrentBag<>(this);
this.suspendResumeLock = config.isAllowPoolSuspension() ? new SuspendResumeLock() : SuspendResumeLock.FAUX_LOCK;
LinkedBlockingQueue<Runnable> addConnectionQueue = new LinkedBlockingQueue<>(maxPoolSize);
this.addConnectionQueueReadOnlyView = unmodifiableCollection(addConnectionQueue);
this.addConnectionExecutor = createThreadPoolExecutor(addConnectionQueue, poolName + " connection adder", threadFactory, new ThreadPoolExecutor.DiscardOldestPolicy());
this.closeConnectionExecutor = createThreadPoolExecutor(maxPoolSize, poolName + " connection closer", threadFactory, new ThreadPoolExecutor.CallerRunsPolicy());
this.houseKeeperTask = houseKeepingExecutorService.scheduleWithFixedDelay(new HouseKeeper(), 100L, housekeepingPeriodMs, MILLISECONDS);
...
}
HikariPool 是为HikariCP提供基本池行为的主要连接池类。
houseKeepingExecutorService.scheduleWithFixedDelay(new HouseKeeper(), 100L, housekeepingPeriodMs, MILLISECONDS)
这行代码是 创建保持连接池连接数量的任务。该任务会关闭需要被丢弃的连接,保证最小连接数,HouseKeeper类的run()
方法中有一行代码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((i < connectionsToAdd - 1) ? poolEntryCreator : postFillPoolEntryCreator);
}
...
}
来看一下PoolEntryCreator是如何创建连接的。
@Override
public Boolean call()
{
while (poolState == POOL_NORMAL && shouldCreateAnotherConnection()) {
final PoolEntry poolEntry = createPoolEntry();
if (poolEntry != null) {
connectionBag.add(poolEntry);
return Boolean.TRUE;
}
}
...
return Boolean.FALSE;
}
PoolEntryCreator实现了Callable接口,在call()方法里可以看到创建连接的过程。来继续看一下createPoolEntry()方法。
private PoolEntry createPoolEntry()
{
final PoolEntry poolEntry = newPoolEntry();
...
}
继续进入newPoolEntry()方法。
PoolEntry newPoolEntry() throws Exception
{
return new PoolEntry(newConnection(), this, isReadOnly, isAutoCommit);
}
PoolEntry构造时会先创建Connection对象传入构造函数中。PoolEntry是ConcurrentBag实例中用来跟踪Connection的。
获取链接
获取链接是通过getConnection()方法获取的,源码如下。
public Connection getConnection() throws SQLException
{
if (isClosed()) {
throw new SQLException("HikariDataSource " + this + " has been closed.");
}
if (fastPathPool != null) {
return fastPathPool.getConnection();
}
HikariPool result = pool;
if (result == null) {
synchronized (this) {
result = pool;
if (result == null) {
validate();
LOGGER.info("{} - Starting...", getPoolName());
try {
pool = result = new HikariPool(this);
this.seal();
}
catch (PoolInitializationException pie) {
if (pie.getCause() instanceof SQLException) {
throw (SQLException) pie.getCause();
}
else {
throw pie;
}
}
LOGGER.info("{} - Start completed.", getPoolName());
}
}
}
会先去fastPathPool获取连接,如果fastPathPool为null,就会通过pool获取,如果pool也为null,会通过 双检 代码来初始化线程池。
这个上文提到过为什么两个HikariPool,fastPathPool是 final 修饰的,而pool是 volatile 修饰的,这就说明fastPathPool比pool性能更高,所以建议要用有参构造来创建HikariDataSource
,才能享受到这点小细节的优化。
继续进入HikariPool#getConnection(final long hardTimeout),方法中有一行关键的代码PoolEntry poolEntry = connectionBag.borrow(timeout, MILLISECONDS)
,这行代码的作用是从ConcurrentBag
中借出一个PoolEntry
对象。PoolEntry
可以看作是对Connection
对象的封装,连接池中存储的连接其实就是一个个的PoolEntry
。
这个connectionBag是用来做什么的呢?
ConcurrentBag
ConcurrentBag 是HikariCP自定义的一个无锁并发集合类。我们接着来看一下 ConcurrentBag 的成员变量。
private final CopyOnWriteArrayList<T> sharedList;
private final boolean weakThreadLocals;
private final ThreadLocal<List<Object>> threadList;
private final IBagStateListener listener;
private final AtomicInteger waiters;
private volatile boolean closed;
private final SynchronousQueue<T> handoffQueue;
属性 | 类型 | 描述 |
---|---|---|
sharedList | CopyOnWriteArrayList | 存放 PoolEntry 对象 |
weakThreadLocals | boolean | 是否使用弱引用 |
threadList | ThreadLocal | 存放当前线程的 PoolEntry 对象 |
listener | IBagStateListener | 添加元素的监听器 |
waiters | AtomicInteger | 当前等待的线程数 |
closed | boolean | 是否关闭 |
handoffQueue | SynchronousQueue | 公平模式队列,即先进先出 |
回到borrow()方法,看一下borrow的实现逻辑。
public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException
{
final List<Object> list = threadList.get();
for (int i = list.size() - 1; i >= 0; i--) {
final Object entry = list.remove(i);
@SuppressWarnings("unchecked")
final T bagEntry = weakThreadLocals ? ((WeakReference<T>) entry).get() : (T) entry;
if (bagEntry != null && bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
return bagEntry;
}
}
final int waiting = waiters.incrementAndGet();
try {
for (T bagEntry : sharedList) {
if (bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
if (waiting > 1) {
listener.addBagItem(waiting - 1);
}
return bagEntry;
}
}
listener.addBagItem(waiting);
timeout = timeUnit.toNanos(timeout);
do {
final long start = currentTime();
final T bagEntry = handoffQueue.poll(timeout, NANOSECONDS);
if (bagEntry == null || bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
return bagEntry;
}
timeout -= elapsedNanos(start);
} while (timeout > 10_000);
return null;
}
finally {
waiters.decrementAndGet();
}
}
-
先从ThreadLocal中获取以前用过的连接。ThreadLocal是当前线程的缓存,加快本地连接获取速度。
-
ThreadLocal中未获取到,会尝试从sharedList中获取,sharedList集合存在初始化的PoolEntry。sharedList是CopyOnWriteArrayList类型的,写时复制,特别适合这种读多写少的场景。
-
sharedList中未获取到那就到阻塞队列中等着,看有没有归还的连接可以使用。
释放连接
用完连接后我们要释放,通过connection.close()释放连接,释放连接时HakariCP也做到了一些巧妙的细节。ProxyConnection的close()方法是HakariCP释放连接的实现逻辑。我们知道连接关闭前必须要关闭Statement,HakariCP对这里做了优化,来看一下代码实现。
private final FastList<Statement> openStatements;
private synchronized void closeStatements()
{
final int size = openStatements.size();
if (size > 0) {
for (int i = 0; i < size && delegate != ClosedConnection.CLOSED_CONNECTION; i++) {
try (Statement ignored = openStatements.get(i)) {
}
catch (SQLException e) {
LOGGER.warn("{} - Connection {} marked as broken because of an exception closing open statements during Connection.close()",
poolEntry.getPoolName(), delegate);
leakTask.cancel();
poolEntry.evict("(exception closing Statements during Connection.close())");
delegate = ClosedConnection.CLOSED_CONNECTION;
}
}
openStatements.clear();
}
}
存储Statement对象用的是 FastList,这也是 HakariCP 之所以快的原因之一。
为什么用FastList而不用ArrayList呢?
-
去掉索引范围检查:查看源码会发现,FastList的get()方法比ArrayList少了一行代码
rangeCheck(index)
,这行代码的作用是范围检查,少了这行代码必然会性能更优。不禁感叹真的是太细了啊,到处都是细节。 -
尾部删除:FastList#remove()方法是从尾部开始扫描的,而并不是从头部开始扫描的。因为Connection的打开和关闭顺序通常是相反的。FastList的根据下标删除方法也去掉索引范围检查。
关闭掉Statement之后,我们再回过头来继续往下看。
poolEntry.recycle(lastAccess);
recycle方法会将该连接归还给线程池,recycle方法套了好几层,最终执行的是ConnectionBag的recycle方法,我们直接进入看一下。
public void requite(final T bagEntry)
{
bagEntry.setState(STATE_NOT_IN_USE);
for (int i = 0; waiters.get() > 0; i++) {
if (bagEntry.getState() != STATE_NOT_IN_USE || handoffQueue.offer(bagEntry)) {
return;
}
else if ((i & 0xff) == 0xff) {
parkNanos(MICROSECONDS.toNanos(10));
}
else {
Thread.yield();
}
}
final List<Object> threadLocalList = threadList.get();
if (threadLocalList.size() < 50) {
threadLocalList.add(weakThreadLocals ? new WeakReference<>(bagEntry) : bagEntry);
}
}
首先将状态设置为未使用,然后判断当前是否存在等待连接的线程,如果存在则将连接加入到公平队列中,由队列中有等待连接的线程则会从阻塞队列中去获取使用;如果当前没有等待连接的线程,并且ThreadLocal中的连接小于50,则将连接添加到本地线程变量ThreadLocal缓存中,当前线程下次获取连接时直接可从ThreadLocal中获取到。
总结
这次源码探究,真的感觉看到了无数个小细节,无数个小优化,积少成多。平时开发过程中,一些小的细节也一定要“扣”。
原文地址:“光”速?HakariCP为什么这么快?