对象池模式（Object Pool Pattern）

Posted 2021-12-03 Tom弹架构

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了对象池模式（Object Pool Pattern）相关的知识，希望对你有一定的参考价值。

1　对象池模式的定义

对象池模式（Object Pool Pattern），是创建型设计模式的一种，将对象预先创建并初始化后放入对象池中，对象提供者就能利用已有的对象来处理请求，减少频繁创建对象所占用的内存空间和初始化时间。
一个对象池包含一组已经初始化并且可以使用的对象，可以在有需求时创建和销毁对象。对象池的用户可以从池子中取得对象，对其进行操作处理，并在不需要时归还给池子而非直接销毁。对象池是一个特殊的工厂对象，对象池模式就是单例模式加享元模式。

2　对象池模式的应用场景

对象池模式主要适用于以下应用场景。

（1）资源受限的场景。比如，不需要可伸缩性的环境（CPU\\内存等物理资源有限），CPU性能不够强劲，内存比较紧张，垃圾收集，内存抖动会造成比较大的影响，需要提高内存管理效率，响应性比吞吐量更为重要。

（2）在内存中数量受限的对象。

（3）创建成本高的对象，可以考虑池化。

补充：常见的使用对象池的场景有在使用Socket时的各种连接池、线程池、数据库连接池等。

3　对象池模式的UML类图

对象池模式的UML类图如下图所示。

由上图可以看到，对象池模式主要包含3个角色。

（1）对象池（ObjectPool）：持有对象并提供取/还等方法。

（2）抽象池化对象（PooledObject）：对池中对象的抽象。

（3）具体池化对象（ConcretePoolObject）：对池中对象的封装，封装对象的状态和一些其他信息。

4　对象池模式的通用写法

以下是对象池模式的通用写法。


public class Client {

    public static void main(String[] args) {
        ObjectPool pool = new ObjectPool(10,50);
        IPooledObject object = pool.borrowObject();
        object.operation();
        pool.returnObject(object);
        System.out.println();
    }

    //抽象对象
    interface IPooledObject {
        void operation();
    }
    //具体对象
    static class ConcretePoolObject implements IPooledObject {
        public void operation() {
            System.out.println("doing");
        }
    }

    //对象池
    static class ObjectPool {
        private int step = 10;                      //当对象不够用的时候，每次扩容的数量
        private int minCount;
        private int maxCount;
        private Vector<IPooledObject> returneds;    //保存未借出的对象
        private Vector<IPooledObject> borroweds;    //保存已被借出的对象

        //初始化对象池
        public ObjectPool(int minCount,int maxCount){
            borroweds = new Vector<IPooledObject>();
            returneds = new Vector<IPooledObject>();

            this.minCount = minCount;
            this.maxCount = maxCount;

            refresh(this.minCount);
        }

        //因为内部状态具备不变性，所以作为缓存的键
        public IPooledObject borrowObject() {
            IPooledObject next = null;
            if(returneds.size() > 0){
                Iterator<IPooledObject> i = returneds.iterator();
                while (i.hasNext()){
                    next = i.next();
                    returneds.remove(next);
                    borroweds.add(next);
                    return next;
                }
            }else{
                //计算出剩余可创建的对象数
                int count = (maxCount - minCount);
                //剩余可创建的数量大于单次固定创建的对象数
                //则再初始化一批固定数量的对象
                refresh(count > step ? step : count);
            }
            return next;
        }

        //不需要使用的对象归还重复利用
        public void returnObject(IPooledObject pooledObject){
            returneds.add(pooledObject);
            if(borroweds.contains(pooledObject)){
                borroweds.remove(pooledObject);
            }
        }

        private void refresh(int count){
            for (int i = 0; i < count; i++) {
                returneds.add(new ConcretePoolObject());
            }
        }
    }
}

对象池模式和享元模式的最大区别在于，对象池模式中会多一个回收对象重复利用的方法。所以，对象池模式应该是享元模式更加具体的一个应用场景。相当于先将对象从对象池中借出，用完之后再还回去，以此保证有限资源的重复利用。