Object Pool对象池化技术

Object Pool对象池化技术

并非所有对象都适合拿来池化??因为维护对象池也要造成一定开销。对生成时开销不大的对象进行池化，反而可能会出现“维护对象池的开销”大于“生成新对象的开销”，从而使性能降低的情况。但是对于生成时开销可观的对象，池化技术就是提高性能的有效策略了。

This is my ObjectFactory using object pool:

import org.apache.commons.pool.KeyedPoolableObjectFactory;
import org.apache.commons.pool.impl.GenericKeyedObjectPool;
import org.apache.commons.pool.impl.GenericKeyedObjectPool.Config;


public class StateMachineFactory implements KeyedPoolableObjectFactory
{

    private static GenericKeyedObjectPool _objectPool = null;

    public Object makeObject(Object key) throws Exception
    {
        ResumeableVendorOrderProcessor resumeableVendorOrderProcessor = null;
        Class aClass = null;

        if ((null != key))
        {
            try
            {
                aClass = Class.forName("the process class name, you need change this", true, this.getClass().getClassLoader());
                resumeableVendorOrderProcessor = (ResumeableVendorOrderProcessor) aClass.newInstance();
            }
            catch (Exception e)
            {
                Log.error(this, "makeObject() exception:" + e);
            }
        }
        return (resumeableVendorOrderProcessor);
    }

    public void destroyObject(Object key, Object object) throws Exception
    {

    }

    public boolean validateObject(Object key, Object object)
    {
        return (true);
    }

    public static ResumeableVendorOrderProcessor getNewInstance(Object key)
    {
        Log.info(StateMachineFactory.class, "getNewInstance() - key: " + key);
        ResumeableVendorOrderProcessor resumeableVendorOrderProcessor = null;
        Class aClass = null;

        if ((null != key))
        {
            try
            {
                aClass = Class.forName("the process class name, you need change this");
                resumeableVendorOrderProcessor = (ResumeableVendorOrderProcessor) aClass.newInstance();
            }
            catch (Exception e)
            {
                Log.error(StateMachineFactory.class, "getNewInstance() exception:" + e);
            }
        }
        return (resumeableVendorOrderProcessor);
    }

    synchronized public static ResumeableVendorOrderProcessor getInstance(Object key)
    {
        ResumeableVendorOrderProcessor resumeableVendorOrderProcessor = null;
        String vendorId = "";

        try
        {
            if (null == _objectPool)
            {
                initObjectPool(false);
            }

            if ((null != key) && (null != _objectPool))
            {
                vendorId = (String) key;
                if (vendorId != null && !"".equals(vendorId))
                {
                    resumeableVendorOrderProcessor = (ResumeableVendorOrderProcessor) _objectPool.borrowObject(vendorId);
                }
            }
        }
        catch (Throwable e)
        {
            Log.error(StateMachineFactory.class, "makeObject() exception:" + e);
        }
        return (resumeableVendorOrderProcessor);
    }

    synchronized public static void returnInstance(Object key, ResumeableVendorOrderProcessor resumeableVendorOrderProcessor)
    {
        String vendorId = null;

        if ((null != key) && (null != _objectPool))
        {
            try
            {
                vendorId = (String) key;
                Log.info(StateMachineFactory.class, "returnInstance() - Returning " + key);
                _objectPool.returnObject(vendorId, resumeableVendorOrderProcessor);
            }
            catch (Throwable aThrowable)
            {
                aThrowable.printStackTrace();
            }
        }
    }

    synchronized public static void initObjectPool(boolean forceInit)
    {
        Log.info(StateMachineFactory.class, "initObjectPool()");

        Config poolConfiguation = null;

        if ((null == _objectPool) || forceInit)
        {
            _objectPool = new GenericKeyedObjectPool(new StateMachineFactory());
            poolConfiguation = getPoolConfiguration();
            _objectPool.setConfig(poolConfiguation);
        }
    }

    private static Config getPoolConfiguration()
    {
        Log.info(StateMachineFactory.class, "getPoolConfiguration()");

        Config poolConfiguration = new Config();
        // Per key
        poolConfiguration.maxActive = 25;
        // For entire pool
        poolConfiguration.maxTotal = 2500;
        return (poolConfiguration);
    }

    public void activateObject(Object key, Object object) throws Exception
    {
        Log.info(StateMachineFactory.class, "activeObject");
    }

    public void passivateObject(Object key, Object object) throws Exception
    {
        Log.info(StateMachineFactory.class, "passivateObject");
    }

}

We can call getInstance and returnObject to use object in pool
Everytime you returnObject, you need confirm that the object is stateless, or you need to re-init them.