干掉Druid，HakariCP 为什么这么快？

<dependency>
    <groupId>com.zaxxer</groupId>
    <artifactId>HikariCP</artifactId>
    <version>4.0.3</version>
</dependency>

@Test
public void testHikariCP() throws SQLException {
    // 1、创建Hikari配置
    HikariConfig hikariConfig = new HikariConfig();
    // JDBC连接串
    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);

    // 2、创建数据源
    HikariDataSource dataSource = new HikariDataSource(hikariConfig);

    // 3、获取连接
    Connection connection = dataSource.getConnection();

    // 4、获取Statement
    Statement statement = connection.createStatement();

    // 5、执行Sql
    ResultSet resultSet = statement.executeQuery("SELECT COUNT(*) AS countNum tt_user");

    // 6、输出执行结果
    if (resultSet.next()) {
        System.out.println("countNum结果为：" + resultSet.getInt("countNum"));
    }

    // 7、释放链接
    resultSet.close();
    statement.close();
    connection.close();
    dataSource.close();
}

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();
}

public HikariPool(final HikariConfig config)
{
   super(config);
   // 初始化ConcurrentBag对象
   this.connectionBag = new ConcurrentBag<>(this);
   // 创建SuspendResumeLock对象 
   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);
   ...
}

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);
    }
    ...
}

@Override
public Boolean call()
{
   // 连接池状态正常并且需求创建连接时
   while (poolState == POOL_NORMAL && shouldCreateAnotherConnection()) {
      // 创建PoolEntry对象
      final PoolEntry poolEntry = createPoolEntry();
      if (poolEntry != null) {
         // 将PoolEntry对象添加到ConcurrentBag对象中的sharedList中
         connectionBag.add(poolEntry);
         return Boolean.TRUE;
      }
   }
   ...
   return Boolean.FALSE;
}

 private PoolEntry createPoolEntry()
{
    // 初始化PoolEntry对象
    final PoolEntry poolEntry = newPoolEntry();
    ...
}

PoolEntry newPoolEntry() throws Exception
{
   return new PoolEntry(newConnection(), this, isReadOnly, isAutoCommit);
}

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());
         }
      }
   }

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;

public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException
{
   // 从ThreadLocal中获取当前线程绑定的对象集合，存在则获取
   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 {
      // sharedList有未使用的则返回一个
      for (T bagEntry : sharedList) {
         if (bagEntry.compareAndSet(STATE_NOT_IN_USE, STATE_IN_USE)) {
            // If we may have stolen another waiter's connection, request another bag add.
            if (waiting > 1) {
               listener.addBagItem(waiting - 1);
            }
            return bagEntry;
         }
      }
      // sharedList没有，添加一个监听任务
      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();
   }
}

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();
   }
}

poolEntry.recycle(lastAccess);

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);
   }
}