性能原理

public final class ProxyFactory
{
    private ProxyFactory() { }

    static ProxyConnection getProxyConnection(final PoolEntry poolEntry, 
                                              final Connection connection, 
                                              final FastList<Statement> openStatements, 
                                              final ProxyLeakTask leakTask, 
                                              final long now, 
                                              final boolean isReadOnly, 
                                              final boolean isAutoCommit){  
    //body部分被JavassistProxyFactory重新注入了
	throw new IllegalStateException("You need to run the CLI build and you
need target/classes in your classpath to run.");
    }

    static Statement getProxyStatement(final ProxyConnection connection, final
Statement statement)
    {//body部分被JavassistProxyFactory重新注入了
        throw new IllegalStateException("You need to run the CLI build and you
need target/classes in your classpath to run.");
    }

    static CallableStatement getProxyCallableStatement(final ProxyConnection
connection, final CallableStatement statement)
    {//body部分被JavassistProxyFactory重新注入了
        throw new IllegalStateException("You need to run the CLI build and you
need target/classes in your classpath to run.");
    }

    static PreparedStatement getProxyPreparedStatement(final ProxyConnection
connection, final PreparedStatement statement)
    {//body部分被JavassistProxyFactory重新注入了
        throw new IllegalStateException("You need to run the CLI build and you
need target/classes in your classpath to run.");
    }

      static  ResultSet  getProxyResultSet(final  ProxyConnection  connection,  final
ProxyStatement statement, final ResultSet resultSet)
    {//body部分被JavassistProxyFactory重新注入了
        throw new IllegalStateException("You need to run the CLI build and you
need target/classes in your classpath to run.");
    }
}

try (Connection con = dataSource.getConnection();
     PreparedStatement stmt = con.prepareStatement(...)) {

    int batchCount = 0;
    for (something in somelist) {
        stmt.setString(...);
        stmt.setInt(...);
        stmt.addBatch();

        if (++batchCount == 100) {
            stmt.executeBatch();
            stmt.clearBatch();
            batchCount = 0;
        }
    }
    if (batchCount > 0) {
            stmt.executeBatch();
            stmt.clearBatch();
    }
    con.commit();
}
catch (SQLException e) {
        // 记录异常
}

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); //新添加的资源优先放入CopyOnWriteArrayList
    // 当有等待资源的线程时，将资源交到某个等待线程后才返回（SynchronousQueue）
    while (waiters.get() > 0 && ! handoffQueue.offer(bagEntry)) {
        yield();
    }
}

public boolean remove(final T bagEntry){
		// 如果资源正在使用且无法进行状态切换，则返回失败
    if (!bagEntry.compareAndSet(STATE_IN_USE, STATE_REMOVED) && 
        !bagEntry.compareAndSet(STATE_RESERVED, STATE_REMOVED) && 
        !closed) {
        LOGGER.warn("Attempt to remove an object from the bag that was not borrowed or reserved: {}", bagEntry);
        return false;
    }
    final boolean removed = sharedList.remove(bagEntry); // 移出
    if (! removed && ! closed) {
        LOGGER.warn("Attempt to remove an object from the bag that does not exist: {}", bagEntry);
    }
    return removed;
}
// ConcurrentBag中通过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)) {//优先从当前线程的ThreadLocal中获取连接，若获得则直接返回
            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();
    }
}

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 {
            yield();
        }
    }
    // 否则，进行资源本地化
    final List<Object> threadLocalList = threadList.get();
    threadLocalList.add(weakThreadLocals ? new WeakReference<>(bagEntry) ：bagEntry);
}

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

public SynchronousQueue() {
    this(false);
}
public SynchronousQueue(boolean fair) {
    // 通过fair值来决定公平和不公平
    // 公平使用TransferQueue，不公平使用TransferStack
    transferer = fair ? new TransferQueue<E>() : new TransferStack<E>();
}

public class CopyOnWriteArrayList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
    final transient ReentrantLock lock = new ReentrantLock(); //可重入锁
    final Object[] getArray() {return array; }//非private，得到数组
    final void setArray(Object[] a) {array = a; }//设置数组
    public CopyOnWriteArrayList() { setArray(new Object[0]); }//初始化

    public boolean add(E e) {
    final ReentrantLock lock = this.lock; //1）加锁
    lock.lock();
    try {
        Object[] elements = getArray(); //得到原数组的长度和元素
        int len = elements.length;
        Object[] newElements = Arrays.copyOf(elements, len + 1); //2）复制数组
        newElements[len] = e; //3）将元素加入到新数组中
        setArray(newElements); //4）将array引用指向到新数组
        return true;
    } finally {
        lock.unlock(); //5）解锁
    }
}