深入研究池化技术——对象池

    <dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
    <version>2.11.1</version>
    </dependency>

    public class SlowObject {
    public SlowObject(String name, Integer age) {
        this.name = name;
        this.age = age;
    }
    
    public static SlowObject init() {
        //模拟对象创建慢的场景
        try {
            Thread.sleep(10L);
        }catch (InterruptedException e) {
            e.printStackTrace();
        }
        return new SlowObject("小飞龙",20);
    }
    
    private String name;
    private Integer age;
    
    //getter and setter...
    
    }

     	@Override
    public void activateObject(PooledObject<SlowObject> pooledObject) throws Exception {
        LOGGER.info("activateObject....state = {}",pooledObject.getState());
    }
    
    @Override
    public void destroyObject(PooledObject<SlowObject> pooledObject) throws Exception {
        LOGGER.info("destroyObject....state = {}",pooledObject.getState());
    }
    
    @Override
    public PooledObject<SlowObject> makeObject() throws Exception {
        DefaultPooledObject<SlowObject> object = new DefaultPooledObject<>(new SlowObject("小飞龙", 20));
        LOGGER.info("makeObject....state = {}",object.getState());
        return object;
    }
    
    @Override
    public void passivateObject(PooledObject<SlowObject> pooledObject) throws Exception {
        LOGGER.info("passivateObject....state = {}",pooledObject.getState());
    
    }
    
    @Override
    public boolean validateObject(PooledObject<SlowObject> pooledObject) {
        LOGGER.info("validateObject....state = {}",pooledObject.getState());
        return true;
    }

    	public static void main(String[] args) throws Exception {
        //创建对象池
        GenericObjectPool<SlowObject> pool = new GenericObjectPool<>(new SlowObjectPooledObjectFactory());
        //获取对象
        SlowObject slowObject = pool.borrowObject();
        //重新赋值
        slowObject.setAge(21);
        //再把对象归还对象池
        pool.returnObject(slowObject);
    }

    		public void run() {
            ClassLoader savedClassLoader = Thread.currentThread().getContextClassLoader();
    
            try {
            //校验ClassLoader
                if (BaseGenericObjectPool.this.factoryClassLoader != null) {
                    ClassLoader cl = (ClassLoader)BaseGenericObjectPool.this.factoryClassLoader.get();
                    if (cl == null) {
                        this.cancel();
                        return;
                    }
    
                    Thread.currentThread().setContextClassLoader(cl);
                }
    
                try {
                    BaseGenericObjectPool.this.evict();
                } catch (Exception var9) {
                    BaseGenericObjectPool.this.swallowException(var9);
                } catch (OutOfMemoryError var10) {
                    var10.printStackTrace(System.err);
                }
    
                try {
                    BaseGenericObjectPool.this.ensureMinIdle();
                } catch (Exception var8) {
                    BaseGenericObjectPool.this.swallowException(var8);
                }
    
            } finally {
                Thread.currentThread().setContextClassLoader(savedClassLoader);
            }
        }

    	private int getNumTests() {
        int numTestsPerEvictionRun = this.getNumTestsPerEvictionRun();
        return numTestsPerEvictionRun >= 0 ? Math.min(numTestsPerEvictionRun, this.idleObjects.size()) : (int)Math.ceil((double)this.idleObjects.size() / Math.abs((double)numTestsPerEvictionRun));
    }

    	public boolean evict(EvictionConfig config, PooledObject<T> underTest, int idleCount) {
        return config.getIdleSoftEvictDuration().compareTo(underTest.getIdleDuration()) < 0 && config.getMinIdle() < idleCount || config.getIdleEvictDuration().compareTo(underTest.getIdleDuration()) < 0;
    }