ConcurrentBag是什么

ConcurrentBag是HikariCP中实现的一个无锁化集合，比JDK中的LinkedBlockingQueue和LinkedTransferQueue的性能更好。借鉴了C#中的设计，作者在这篇文章中说提到的几个点是：

A lock-free design
ThreadLocal caching
Queue-stealing
Direct hand-off optimizations

源码剖析

设计目的

ConcurrentBag的类注释如下：

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

简单翻译一下：

ConcurrentBag是为追求链接池操作高性能而设计的并发工具。它使用ThreadLocal缓存来避免锁争抢，当ThreadLocal中没有可用的链接时会去公共集合中“借用”链接。ThreadLocal中处于Not-in-use状态的链接也可能会“借走”。

ConcurrentBag使用AbstractQueuedLongSynchronizer来管理跨线程通信（实际新版本已经删掉了AbstractQueuedLongSynchronizer）。

注意被“借走”的链接并没有从任何集合中删除，所以即使链接的引用被弃用也不会进行gc。所以要及时将被“借走”的链接归还回来，否则可能会发生内存泄露。只有remove方法才会真正将链接从ConcurrentBag中删除。

看下HikariCP中是如何实现ConcurrentBag的。

源码实现

类定义

public class ConcurrentBag implements AutoCloseable

ConcurrentBag只是实现了AutoCloseable接口，而没有实现List或Map等接口。其中的元素要集成IConcurrentBagEntry。我们看下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();
   }

再看下类成员变量：


   //存放共享元素，线程安全的List
   private final CopyOnWriteArrayList sharedList;
   //是否使用弱引用
   private final boolean weakThreadLocals;

   //线程本地缓存
   private final ThreadLocal> threadList;
   //添加元素的监听器，在HikariPool中实现
   private final IBagStateListener listener;
   //当前等待获取元素的线程数
   private final AtomicInteger waiters;
   //ConcurrentBag是否处于关于状态
   private volatile boolean closed;

   //接力队列
   private final SynchronousQueue handoffQueue;

链接PoolEntry

在HikariCP中使用PoolEntry对链接实例Connection进行了封装，记录了Connection相关的数据，如Connection实例、链接状态、当前活跃会话、对链接池引用等。

PoolEntry也是ConcurrentBag管理的对象，sharedList和threadList中保存的对象就是PoolEntry的实例。

/**
 * Entry used in the ConcurrentBag to track Connection instances.
 *
 * @author Brett Wooldridge
 */
final class PoolEntry implements IConcurrentBagEntry {
   //用来更新链接的状态state
   private static final AtomicIntegerFieldUpdater stateUpdater;
   //链接实例
   Connection connection;
   //链接状态，如STATE_IN_USE、STATE_NOT_IN_USE
   private volatile int state;
   //驱逐状态，删除该链接时标记为true
   private volatile boolean evict;
   //当前打开的会话
   private final FastList openStatements;
   //链接池引用
   private final HikariPool hikariPool;

   private final boolean isReadOnly;
   private final boolean isAutoCommit;
}

ConcurrentBag中的方法比较少，我们一个个看一下：

1. 增加链接

add方法很简单，只是将新的链接放入sharedList中，如果有等待链接的线程，则将链接给该线程。

可以发现其实所有的链接都保存在sharedList中，ThreadList只是其中一部分。

/**
 * Add a new object to the bag for others to borrow.
 *
 *@parambagEntryan object to add to the bag
 */
public void add(final T bagEntry) {
   if (closed) {
LOGGER.info("ConcurrentBag has been closed, ignoring add()");
      throw new IllegalStateException("ConcurrentBag has been closed, ignoring add()");
   }

    //将链接放入共享队列
   sharedList.add(bagEntry);

   // spin until a thread takes it or none are waiting
   // 等待直到没有waiter或有线程拿走它
   while (waiters.get() > 0 && !handoffQueue.offer(bagEntry)) {
       //yield什么都不做，只是为了让渡CPU使用，避免长期占用
       yield();
   }
}

2. 获取链接

链接获取顺序：

从线程本地缓存ThreadList中获取，这里保持的是该线程之前使用过的链接
从共享集合sharedList中获取，如果获取不到，会通知listener新建链接（但不一定真的会新建链接出来）
从handoffQueue中阻塞获取，新建的链接或一些转为可用的链接会放入该队列中

   /**
    * The method will borrow a BagEntry from the bag, blocking for the
    * specified timeout if none are available.
    *
    * @param timeout how long to wait before giving up, in units of unit
    * @param timeUnit a TimeUnit determining how to interpret the timeout parameter
    * @return a borrowed instance from the bag or null if a timeout occurs
    * @throws InterruptedException if interrupted while waiting
    */
   public T borrow(long timeout, final TimeUnit timeUnit) throws InterruptedException {
      // 先看是否能从ThreadList中拿到可用链接，这里的List通常为FastList
      List

HikariCP源码简洁剖析——ConcurrentBag