【HikariCP】【ConcurrentBag】源码学习

Hikari目前已经是springboot的默认数据库连接池，并且以高效和轻量著称，因为代码量比较少，所以可以阅读一下，学习一下，github地址：HikariCP

ConcurrentBag

这个是HikariCP的核心功能类，作者在注释中也详细说明了这个类的作用

/**
 * This is a specialized concurrent bag that achieves superior performance
 * to LinkedBlockingQueue and LinkedTransferQueue for the purposes of a
 * connection pool.  It uses ThreadLocal storage when possible to avoid
 * locks, but resorts to scanning a common collection if there are no
 * available items in the ThreadLocal list.  Not-in-use items in the
 * ThreadLocal lists can be "stolen" when the borrowing thread has none
 * of its own.  It is a "lock-less" implementation using a specialized
 * AbstractQueuedLongSynchronizer to manage cross-thread signaling.
 *
 * Note that items that are "borrowed" from the bag are not actually
 * removed from any collection, so garbage collection will not occur
 * even if the reference is abandoned.  Thus care must be taken to
 * "requite" borrowed objects otherwise a memory leak will result.  Only
 * the "remove" method can completely remove an object from the bag.
 *
 * @author Brett Wooldridge
 *
 * @param  the templated type to store in the bag
 */
public class ConcurrentBag implements AutoCloseable

翻译能力有限，借助谷歌翻译，大致意思如下：

这是一个专门的并发包，可以为连接池实现LinkedBlockingQueue和LinkedTransferQueue的卓越性能。 它尽可能使用ThreadLocal存储来避免锁定，但如果ThreadLocal列表中没有可用的项目，则会使用它来扫描公共集合。 当借用线程没有自己的东西时，ThreadLocal列表中的未使用项可能被“窃取”。 它是一个“无锁”实现，使用专门的AbstractQueuedLongSynchronizer来管理跨线程信令。

请注意，从包中“借用”的项目实际上并未从任何集合中删除，因此即使放弃引用也不会发生垃圾收集。 因此，必须小心“重新”“借用”借来的对象，否则将导致内存泄漏。 只有“删除”方法才能从包中完全删除对象。

我对这个类的理解就是在多线程的并发场景中，通过自己封装的类，在保证线程安全的情况下维护连接池的安全和高效，数据结构比LinkedBlockingQueue和LinkedTransferQueue这两个queue要高效。

成员变量

• private final CopyOnWriteArrayList sharedList;

这个成员变量首先要注意到的是它是CopyOnWriteArrayList类型的，这个类型是Java并发包中的类，主要就是解决ArrayList在多线程读写场景中会出现的ConcurrentModificationException。ArrayList在内部维护了一个modCount修改次数的成员变量，如果在写的过程中多个线程同时进行修改，那么当前的修改次数和维护的修改次数可能会不一致导致抛出了这个异常。

所以为了避免这个情况，CopyOnWriteArrayList这个类是这么处理的：读是没有影响的，但是如果要往集合中写元素，那么首先会复制出一个当前List的copy，然后在这个copy中添加这个元素，最后把原来List的地址引用指向这个copy。如果在复制的过程中有线程去读取，那么它读到的是原来的集合中的值。这里因为涉及到集合的复制，所以这种一般是用于集合元素比较稳定，基本不会发生写入的情况。如果元素一直在变化，那么在大数据量的情况下复制的开销是很大的。具体的详情可以推荐这个博客查看CopyOnWriteArrayList的原理和使用方法

回到这个成员变量这个是共享元素的集合。这个元素必须是IConcurrentBagEntry的实例，在hikari中就是封装了数据库连接的分装类，也就是连接

• private final boolean weakThreadLocals;

是否是弱引用ThreadLocal

• private final ThreadLocal threadList;

线程持有的成员变量是一个List的借用元素集合

• private final IBagStateListener listener;

包状态监听器接口

• private final AtomicInteger waiters;

原子类，等待者数量

• private volatile boolean closed;

volatile类型，并发包是否关闭

• private final SynchronousQueue handoffQueue;

这个SynchronousQueue是Java并发包中的，大致的作用是它是一个只有容量1的队列，当生产者生产完放入元素后就会阻塞，直到消费者将该元素取出消费。这样做保证了消息的一对一传递。网上随便一搜有很多这个类的说明。

内部接口

• IConcurrentBagEntry

public interface IConcurrentBagEntry
{
  int STATE_NOT_IN_USE = 0;
  int STATE_IN_USE = 1;
  int STATE_REMOVED = -1;
  int STATE_RESERVED = -2;

  boolean compareAndSet(int expectState, int newState);
  void setState(int newState);
  int getState();
}

共享元素需要实现的就是这个接口，这个接口定义了四种状态，还有设置状态、获取状态和设置的状态和想要的状态是否一致三个方法

• IBagStateListener

public interface IBagStateListener
{
  void addBagItem(int waiting);
}

这个监听器接口只有一个方法是增加元素

构造方法

public ConcurrentBag(final IBagStateListener listener)
{
  this.listener = listener;
  this.weakThreadLocals = useWeakThreadLocals();

  this.handoffQueue = new SynchronousQueue<>(true);
  this.waiters = new AtomicInteger();
  this.sharedList = new CopyOnWriteArrayList<>();
  if (weakThreadLocals) {
     this.threadList = ThreadLocal.withInitial(() -> new ArrayList<>(16));
  }
  else {
     this.threadList = ThreadLocal.withInitial(() -> new FastList<>(IConcurrentBagEntry.class, 16));
  }
}

构造器传入一个监听器，然后赋值到成员变量上。weakThreadLocals的赋值是调用方法：

private boolean useWeakThreadLocals()
{
  try {
     if (System.getProperty("com.zaxxer.hikari.useWeakReferences") != null) {   // undocumented manual override of WeakReference behavior
        return Boolean.getBoolean("com.zaxxer.hikari.useWeakReferences");
     }

     return getClass().getClassLoader() != ClassLoader.getSystemClassLoader();
  }
  catch (SecurityException se) {
     return true;
  }
}

这个方法中可以看到首先是使用者配置的时候时候配置了这个选项，如果没有配置，那么检查当前类的类加载器是不是自己定义的类加载器，如果是自己定义的，那么就是弱引用

然后是handoffQueue、waiters和sharedList的实例化。最后的threadList实例化的时候需要检查是否是弱引用，如果是弱引用，那么实例化的是一个16容量的ArrayList，如果不是，那么用的是作者自己开发的FastList。

方法

• public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException

public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException
{
  // Try the thread-local list first
  final List