对象池commons-pool框架的研究以及源代码分析(二)

通过上一节的例子,我们使用了一个简单的对象池应用,现在再来看看其内部是如何实现的。先看看主要包括了哪些类:


该包所有的类与接口不多,也就20个左右,虽然是一个小项目,其中接口与抽象类的数量,基本上与实现的类差不多,可以说明开发者是使用面向接口编程,而不是面向实现编程,对我们的开发工作有着指导意义,在开发中要尽量面向接口编程而非实现。把类整理一下,分成两类,一类是包括KEY的对象池,一类是不包括KEY的对象池,实际上,分析了其中一个,另外的不用分析都知道其实现,先画个简单的类图(没有一个好的画图工具,这图画得不够专业啊,大家将就着看):


绿色部分的类与接口,就是我们前面使用过的类与接口,StackObjectPool就是对象池的具体实现,由图中我们可以看到,对象池的实现,主要包括4类:StackObjectPool,GenericObjectPool,SoftReferenceObjectPool,AbandoneObjectPool。,值得一提的是BaseObjectPool类,其中负责对对象池状态来维护,实际上主要是维护一个isClose属性,不过在设计上,还是可取的,将通用的属性在一个抽象类里面维护。

左边部分,就是我们使用的对象状态维护工厂,由对象池具体实现操作,对对象的状态进行维护。

右边是使用了工厂设计模式,生成利用对象池工厂生成对象池,由于我们的代码只是演示,所以直接在代码中硬编码了,没有使用工厂,在实际编程中是不可取的。

对核心的类、接口有一个整体印象后,我们就可以来看其具体实现了,先来看看StackObjectPool类:

public class StackObjectPool extends BaseObjectPool implements ObjectPool {

先看看属性:

    protected Stack _pool = null;//对象池,是一个Stack,后面可以想象,主要是围绕Stack做操作

    protected static final int DEFAULT_MAX_SLEEPING  = 8;//默认池中对象最大数量,注意是Static与final
    protected static final int DEFAULT_INIT_SLEEPING_CAPACITY = 4;//默认初始化对象的数量,注意是Static与final
值得学习的地方:设置一些默认对象时,尽量设置为final,避免认为的非法修改    

protected PoolableObjectFactory _factory = null;//对象状态维护工厂
  protected int _maxSleeping = DEFAULT_MAX_SLEEPING;//最大对象数量
    protected int _numActive = 0;//被借出对象数量


//设略构造函数5个,构造函数主要是对以上属性设置值

 

 
    public StackObjectPool(PoolableObjectFactory factory, int maxIdle, int initIdleCapacity) {
        _factory = factory;
        _maxSleeping = (maxIdle < 0 ? DEFAULT_MAX_SLEEPING : maxIdle);
        int initcapacity = (initIdleCapacity < 1 ? DEFAULT_INIT_SLEEPING_CAPACITY : initIdleCapacity);
        _pool = new Stack();
        _pool.ensureCapacity( initcapacity > _maxSleeping ? _maxSleeping : initcapacity);

//生成Stack对象,并对对象的大小做初始化   

 }

//借出对象
    public synchronized Object borrowObject() throws Exception {
        assertOpen();
        Object obj = null;
        while (null == obj) {
            if (!_pool.empty()) {//如果对象池非空,就取出对象
                obj = _pool.pop();
            } else {//如果对象池为空,就调用我们传递进来的对象状态维护类来创建对象
                if(null == _factory) {
                    throw new NoSuchElementException();
                } else {
                    obj = _factory.makeObject();
                }
            }
            if(null != _factory && null != obj) {//如果取出对象,就激活对象
                _factory.activateObject(obj);
            }
            if (null != _factory && null != obj && !_factory.validateObject(obj)) {//如果对象验证对象不可用,就销毁掉并返回NULL
                _factory.destroyObject(obj);
                obj = null;
            }
        }
        _numActive++;
        return obj;
    }

//返回对象
    public synchronized void returnObject(Object obj) throws Exception {
        assertOpen();
        boolean success = true;
        if(null != _factory) {
            if(!(_factory.validateObject(obj))) {//如果对象无效
                success = false;
            } else {
                try {
                    _factory.passivateObject(obj);//调用对象返回后的动作进行状态维护
                } catch(Exception e) {
                    success = false;
                }
            }
        }


        boolean shouldDestroy = !success;


        _numActive--;
        if (success) {//对象有效
            Object toBeDestroyed = null;
            if(_pool.size() >= _maxSleeping) {
                shouldDestroy = true;
                toBeDestroyed = _pool.remove(0); // remove the stalest object
            }
            _pool.push(obj);
            obj = toBeDestroyed; // swap returned obj with the stalest one so it can be destroyed
        }
        notifyAll(); // _numActive has changed
//这一段代码写得有点乱,原意是:如果对象数量超出最大限制,取出池中的对象,然后将有效对象放入,取出的对象就等着销毁

        if(shouldDestroy) { // by constructor, shouldDestroy is false when _factory is null
            try {
                _factory.destroyObject(obj);
            } catch(Exception e) {
                // ignored
            }
        }
    }

//将对象设置为无效
    public synchronized void invalidateObject(Object obj) throws Exception {
        assertOpen();
        _numActive--;
        if(null != _factory ) {
            _factory.destroyObject(obj);//实际上就是调用我们传递进来的状态维护类销毁对象
        }
        notifyAll(); // _numActive has changed
    }

//获取对象池空闲对象数量
    public synchronized int getNumIdle() {
        assertOpen();
        return _pool.size();
    }

//获取对象池已被使用的对象数量
    public synchronized int getNumActive() {
        assertOpen();
        return _numActive;
    }

//销毁对象池所有对象,并将对象池清空
    public synchronized void clear() {
        assertOpen();
        if(null != _factory) {
            Iterator it = _pool.iterator();
            while(it.hasNext()) {
                try {
                    _factory.destroyObject(it.next());
                } catch(Exception e) {
                    // ignore error, keep destroying the rest
                }
            }
        }
        _pool.clear();
    }

//清空对象池,并将对象池状态设置为关闭
    public synchronized void close() throws Exception {
        clear();
        _pool = null;
        _factory = null;
        super.close();
    }


     //添加对象
    public synchronized void addObject() throws Exception {
        assertOpen();
        Object obj = _factory.makeObject();//直接调用我们传递的类添加
        _numActive++;   // A little slimy - must do this because returnObject decrements it.
        this.returnObject(obj);
    }

//设置对象状态维护工厂
    public synchronized void setFactory(PoolableObjectFactory factory) throws IllegalStateException {
        assertOpen();
        if(0 < getNumActive()) {
            throw new IllegalStateException("Objects are already active");
        } else {
            clear();
            _factory = factory;
        }
    }


  
}

注意:上面每个方法都是声明为synchronized 的,所以在是线程安全的,在多线程中可以放心使用。














评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值