对象池

平时开发涉及到比如数据库连接、Redis连接等等其他连接，连接在创建、销毁的过程往往比较消耗资源、时间，于是，便出现连接池的概念。
其中不同的连接池都是保存着对象的，只不过有的对象是数据库连接对象，有的对象是Redis连接对象，由此可见，只要我们理解了对象池，则不同的池我们也掌握了原理。

我们基于apache开源的common-pools包来掌握对象池(GenericObjectPool)的原理。

对象池，主要有三个方法
一、borrowObject()
    借一个对象。
二、returnObject(T obj)
    归还对象，正常使用完对象后，归还对象。
三、invalidateObject(T obj)
    废弃对象，在使用对象过程中，对象出现异常（不是指我们的业务代码产生的异常），我们往往需要丢弃掉这个对象，调用这个方法，对象池就可以销毁该对象。

--idleObjects.hasTakeWaiters()获取当前有多少个线程阻塞着在等待空闲对象

一、borrowObject()

##获取池中的对象GenericObjectPool.borrowObject()##
在创建对象池时，我们可以设置阻塞blockWhenExhausted属性，默认为true。
根据是否阻塞？分两个不同策略
1.阻塞
从空闲队列取出队头元素，
如果取到的元素为null，则说明没空闲元素；创建一个对象
如果创建对象为null，则表示创建对象数量已经达到上限，只能阻塞直到空闲队列有可用的元素
进行阻塞:
    如果maxWaitMillis(毫秒)小于0则一直阻塞直到空闲队列有可用的元素；
    如果maxWaitMillis小于等于0则阻塞maxWaitMillis毫秒，从空闲队列取出头元素。
如果取到元素还是null，则抛出异常：等待空闲对象超时。
如果取到元素不是null，则调用boolean PooledObject.allocate()对对象进行分配
如果分配结果为false，则对象分配不成功，对象依然设为null
2.不阻塞
从空闲队列取出队头元素，
如果取到的元素为空，则说明没空闲元素；创建一个对象
如果创建对象为null，则表示创建对象数量已经达到上限，抛出异常：池的对象被全部用完。
如果取到元素不是null，则调用boolean PooledObject.allocate()对对象进行分配
如果分配结果为false，则对象分配不成功，对象依然设为null

通过1或者2取得对象元素，如果获取到对象不为null，执行下面操作:
调用PooledObjectFactory.activateObject(PooledObject<T> p）激活对象，如果activateObject抛出异常，则销毁对象p，且是新创建的对象则抛出异常：激活对象失败
激活对象后，如果testOnBorrow为true或者是新创建的对象且testOnCreate为true，则
调用boolean PooledObjectFactory.validateObject(PooledObject<T> p)验证对象是不是有效的、 可用的，如果验证为false，则销毁对象p，并确认空闲队列中至少有一个空闲对象（调用GenericObjectPool.ensureIdle(1, false) ）

通过上面的过程后，如果对象为null，则循环上面步骤，直到获取对象不为null或者抛出异常；

最后调用方法updateStatsBorrow(p, System.currentTimeMillis() - waitTime)--待留
返回对象
/over.

二、returnObject(T obj)

##归还对象到池中GenericObjectPool.returnObject(T obj)##
从allObjects中获取封装对象的value对象（就是对象T obj的PooledObject对象，假设为p）；
如果p为null，则说明已经被删除了，不做什么操作，直接返回结束方法；

加锁(p){
    如果p状态不是分配状态，则抛出异常：对象已经归还或不可用
    状态是分配状态，则调用PooledObject.markReturning()将p设置为正在归还状态。
}
if(testOnReturn){
    调用boolean PooledObjectFactory.validateObject(PooledObject<T> p)验证对象是不是可用的，如果验证为false，则销毁对象p，并确认空闲队列中至少有一个空闲对象（调用GenericObjectPool.ensureIdle(1, false) ）
}
调用PooledObjectFactory.passivateObject(PooledObject<T> p) 钝化对象，调用有异常抛出则销毁对象p，并确认空闲队列中至少有一个空闲对象（调用GenericObjectPool.ensureIdle(1, false) ）
调用PooledObject.deallocate()将自己设为空闲状态，设置失败则抛出异常：对象已经被归还或是不可用的
如果空闲对象数量不少于maxIdle，则不需要归还该对象，则销毁该对象；否则，根据lifo值将对象加入空闲队列的队头或队尾。
/over.

三、invalidateObject(T obj)

##废弃对象GenericObjectPool.invalidateObject(T obj)##
从allObjects中获取封装对象的value对象（就是对象T obj的PooledObject对象，假设为p）；
如果p为null则抛出异常：对象已经不在池中；
否则，
加锁(p){
    检查p是不是INVALID状态，不是则销毁对象；是INVALID状态，则表示对象已经在销毁中，直接结束方法。
}
确认空闲队列中至少有一个空闲对象（调用GenericObjectPool.ensureIdle(1, false) ）
/over.

++++++++++++++++++++++++++++++++++++++++++++++
GenericObjectPool<T>类
++++++++++++++++++++++++++++++++++++++++++++++

=================
创建一个对象
=================
PooledObject<T> create():
如果创建对象的数量已经大于maxTotal，或者大于int的最大值(2^31-1,2147483647)，则对象数量达到上限，不能创建对象，返回null；
调用PooledObjectFactory<T>.makeOjbect()方法创建对象，如果创建失败，则抛出异常；
创建对象成功，则将新对象put进入allObjects（ConcurrentHashMap对象），返回新对象。
=================

=================
销毁对象
=================
destroy(PooledObject<T> toDestory):
对象调用PooledObject.invalidate()方法将自己作废，即将状态设为state = PooledObjectState.INVALID;
从空闲队列中删除该对象；
allObjects map中删除该对象；
调用工厂对象PooledObjectFactory.destroyObject(PooledObject<T> p)销毁对象，可以在这里释放相关资源等等工作。

=================
确认至少有idleCount个空闲对象
=================
void ensureIdle(int idleCount, boolean always):
always为true则表示不管有没有在阻塞等待的线程(idleObjects.hasTakeWaiters())，都会检查空闲对象的数量，否则，方法结束返回
如果空闲对象数量少于idleCount，则创建新对象放进空闲队列，根据lifo值来放进队列的队头或队尾。
++++++++++++++++++++++++++++++++++++++++++++++


++++++++++++++++++++++++++++++++++++++++++++++
PooledObject
++++++++++++++++++++++++++++++++++++++++++++++

=================
分配
=================
synchronized boolean allocate()://对象同步方法
如果对象状态为空闲PooledObjectState.IDLE，则
    修改状态为分配PooledObjectState.ALLOCATED，
    修改最近借时间和用时间lastBorrowTime = lastBorrowTime = now.
    对象借次数递增borrowedCount++;
    返回true；
如果对象状态为PooledObjectState.EVICTION(暂译：驱逐)，则状态改为PooledObjectState.EVICTION_RETURN_TO_HEAD，返回false；
其他情况都返回false。

=================
归还
=================
void markReturning():
将状态设置归还
state = PooledObjectState.RETURNING;

++++++++++++++++++++++++++++++++++++++++++++++

四、源码

borrowObject

    public T borrowObject(long borrowMaxWaitMillis) throws Exception {
        assertOpen();

        AbandonedConfig ac = this.abandonedConfig;
        if (ac != null && ac.getRemoveAbandonedOnBorrow() &&
                (getNumIdle() < 2) &&
                (getNumActive() > getMaxTotal() - 3) ) {
            removeAbandoned(ac);
        }

        PooledObject<T> p = null;

        // Get local copy of current config so it is consistent for entire
        // method execution
        boolean blockWhenExhausted = getBlockWhenExhausted();

        boolean create;
        long waitTime = System.currentTimeMillis();

        while (p == null) {
            create = false;
            if (blockWhenExhausted) {
                p = idleObjects.pollFirst();
                if (p == null) {
                    p = create();
                    if (p != null) {
                        create = true;
                    }
                }
                if (p == null) {
                    if (borrowMaxWaitMillis < 0) {
                        p = idleObjects.takeFirst();
                    } else {
                        p = idleObjects.pollFirst(borrowMaxWaitMillis,
                                TimeUnit.MILLISECONDS);
                    }
                }
                if (p == null) {
                    throw new NoSuchElementException(
                            "Timeout waiting for idle object");
                }
                if (!p.allocate()) {
                    p = null;
                }
            } else {
                p = idleObjects.pollFirst();
                if (p == null) {
                    p = create();
                    if (p != null) {
                        create = true;
                    }
                }
                if (p == null) {
                    throw new NoSuchElementException("Pool exhausted");
                }
                if (!p.allocate()) {
                    p = null;
                }
            }

            if (p != null) {
                try {
                    factory.activateObject(p);
                } catch (Exception e) {
                    try {
                        destroy(p);
                    } catch (Exception e1) {
                        // Ignore - activation failure is more important
                    }
                    p = null;
                    if (create) {
                        NoSuchElementException nsee = new NoSuchElementException(
                                "Unable to activate object");
                        nsee.initCause(e);
                        throw nsee;
                    }
                }
                if (p != null && (getTestOnBorrow() || create && getTestOnCreate())) {
                    boolean validate = false;
                    Throwable validationThrowable = null;
                    try {
                        validate = factory.validateObject(p);
                    } catch (Throwable t) {
                        PoolUtils.checkRethrow(t);
                        validationThrowable = t;
                    }
                    if (!validate) {
                        try {
                            destroy(p);
                            destroyedByBorrowValidationCount.incrementAndGet();
                        } catch (Exception e) {
                            // Ignore - validation failure is more important
                        }
                        p = null;
                        if (create) {
                            NoSuchElementException nsee = new NoSuchElementException(
                                    "Unable to validate object");
                            nsee.initCause(validationThrowable);
                            throw nsee;
                        }
                    }
                }
            }
        }

        updateStatsBorrow(p, System.currentTimeMillis() - waitTime);

        return p.getObject();
    }

returnObject(T obj)

public void returnObject(T obj) {
        PooledObject<T> p = allObjects.get(new IdentityWrapper<T>(obj));
        
        if (p == null) {
            if (!isAbandonedConfig()) {
                throw new IllegalStateException(
                        "Returned object not currently part of this pool");
            } else {
                return; // Object was abandoned and removed
            }
        }

        synchronized(p) {
            final PooledObjectState state = p.getState();
            if (state != PooledObjectState.ALLOCATED) {
                throw new IllegalStateException(
                        "Object has already been returned to this pool or is invalid");
            } else {
                p.markReturning(); // Keep from being marked abandoned
            }
        }

        long activeTime = p.getActiveTimeMillis();

        if (getTestOnReturn()) {
            if (!factory.validateObject(p)) {
                try {
                    destroy(p);
                } catch (Exception e) {
                    swallowException(e);
                }
                try {
                    ensureIdle(1, false);
                } catch (Exception e) {
                    swallowException(e);
                }
                updateStatsReturn(activeTime);
                return;
            }
        }

        try {
            factory.passivateObject(p);
        } catch (Exception e1) {
            swallowException(e1);
            try {
                destroy(p);
            } catch (Exception e) {
                swallowException(e);
            }
            try {
                ensureIdle(1, false);
            } catch (Exception e) {
                swallowException(e);
            }
            updateStatsReturn(activeTime);
            return;
        }

        if (!p.deallocate()) {
            throw new IllegalStateException(
                    "Object has already been returned to this pool or is invalid");
        }

        int maxIdleSave = getMaxIdle();
        if (isClosed() || maxIdleSave > -1 && maxIdleSave <= idleObjects.size()) {
            try {
                destroy(p);
            } catch (Exception e) {
                swallowException(e);
            }
        } else {
            if (getLifo()) {
                idleObjects.addFirst(p);
            } else {
                idleObjects.addLast(p);
            }
            if (isClosed()) {
                // Pool closed while object was being added to idle objects.
                // Make sure the returned object is destroyed rather than left
                // in the idle object pool (which would effectively be a leak)
                clear();
            }
        }
        updateStatsReturn(activeTime);
    }

invalidateObject(T obj)

public void invalidateObject(T obj) throws Exception {
        PooledObject<T> p = allObjects.get(new IdentityWrapper<T>(obj));
        if (p == null) {
            if (isAbandonedConfig()) {
                return;
            } else {
                throw new IllegalStateException(
                        "Invalidated object not currently part of this pool");
            }
        }
        synchronized (p) {
            if (p.getState() != PooledObjectState.INVALID) {
                destroy(p);
            }
        }
        ensureIdle(1, false);
    }

..