Java對象池示例

Java對象池示例

　　對象池使用的基本思路是：將用過的對象保存起來，等下一次需要這種對象的時候，再拿出來重複使用，從而在一定程度上減少頻繁創建對象所造成的開銷。 並非所有對象都適合拿來池化――因爲維護對象池也要造成一定開銷。對生成時開銷不大的對象進行池化，反而可能會出現“維護對象池的開銷”大於“生成新對象的開銷”，從而使性能降低的情況。但是對於生成時開銷可觀的對象，池化技術就是提高性能的有效策略了。下面是構建對象池的一個例子：

public class ObjectPool {     
    private int numObjects = 10; // 對象池的大小     
    private int maxObjects = 50; // 對象池最大的大小     
    private Vector objects = null; //存放對象池中對象的向量( PooledObject類型)       
  
    public ObjectPool() {            
    }     
    
    /*** 創建一個對象池***/     
    public synchronized void createPool(){     
        // 確保對象池沒有創建。如果創建了，保存對象的向量 objects 不會爲空     
        if (objects != null) {     
            return; // 如果己經創建，則返回     
        }     
    
        // 創建保存對象的向量 , 初始時有 0 個元素     
        objects = new Vector();     
    
        // 根據 numObjects 中設置的值，循環創建指定數目的對象     
        for (int x = 0; x < numObjects; x++) {     
           if ((objects.size() == 0)&&this.objects.size() <this.maxObjects) {  
              Object obj = new Obj();     
              objects.addElement(new PooledObject(obj));               
　　　　　　}
　　　　}
    }     
    
    public synchronized Object getObject(){     
        // 確保對象池己被創建     
        if (objects == null) {     
            return null; // 對象池還沒創建，則返回 null     
        }     
    
        Object conn = getFreeObject(); // 獲得一個可用的對象     
    
        // 如果目前沒有可以使用的對象，即所有的對象都在使用中     
        while (conn == null) {     
            wait(250);     
            conn = getFreeObject(); // 重新再試，直到獲得可用的對象，如果     
            // getFreeObject() 返回的爲 null，則表明創建一批對象後也不可獲得可用對象     
        }     
    
        return conn;// 返回獲得的可用的對象     
    }     
    
    /**   
     * 本函數從對象池對象 objects 中返回一個可用的的對象，如果   
     * 當前沒有可用的對象，則創建幾個對象，並放入對象池中。   
     * 如果創建後，所有的對象都在使用中，則返回 null   
     */    
    private Object getFreeObject(){     
    
        // 從對象池中獲得一個可用的對象     
        Object obj = findFreeObject();     
    
        if (obj == null) {     
            createObjects(incrementalObjects);     //如果目前對象池中沒有可用的對象，創建一些對象     

            // 重新從池中查找是否有可用對象     
            obj = findFreeObject();     
                   
           // 如果創建對象後仍獲得不到可用的對象，則返回 null     
            if (obj == null) {     
                return null;     
            }     
        }     
    
        return obj;     
    }     
    
    /**   
     * 查找對象池中所有的對象，查找一個可用的對象，   
     * 如果沒有可用的對象，返回 null   
     */    
    private Object findFreeObject(){     
    
        Object obj = null;     
        PooledObject pObj = null;     
    
        // 獲得對象池向量中所有的對象     
        Enumeration enumerate = objects.elements();     
    
        // 遍歷所有的對象，看是否有可用的對象     
        while (enumerate.hasMoreElements()) {     
            pObj = (PooledObject) enumerate.nextElement();     
                    
           // 如果此對象不忙，則獲得它的對象並把它設爲忙     
            if (!pObj.isBusy()) {     
                obj = pObj.getObject();     
                pObj.setBusy(true);     
           }
   
        return obj;// 返回找到到的可用對象     
    }     
    
    
    /**   
     * 此函數返回一個對象到對象池中，並把此對象置爲空閒。   
     * 所有使用對象池獲得的對象均應在不使用此對象時返回它。   
     */    
    
    public void returnObject(Object obj) {     
    
        // 確保對象池存在，如果對象沒有創建（不存在），直接返回     
        if (objects == null) {     
            return;     
        }     
    
        PooledObject pObj = null;     
    
        Enumeration enumerate = objects.elements();     
    
        // 遍歷對象池中的所有對象，找到這個要返回的對象對象     
        while (enumerate.hasMoreElements()) {     
            pObj = (PooledObject) enumerate.nextElement();     

            // 先找到對象池中的要返回的對象對象     
            if (obj == pObj.getObject()) {     
                // 找到了 , 設置此對象爲空閒狀態     
                pObj.setBusy(false);     
                break;     
            }     
        }     
    }     
    
    
    /**   
     * 關閉對象池中所有的對象，並清空對象池。   
     */    
    public synchronized void closeObjectPool() {     
    
        // 確保對象池存在，如果不存在，返回     
        if (objects == null) {     
            return;     
        }     
    
        PooledObject pObj = null;     
    
        Enumeration enumerate = objects.elements();     
    
        while (enumerate.hasMoreElements()) {     
    
            pObj = (PooledObject) enumerate.nextElement();     
    
            // 如果忙，等 5 秒     
            if (pObj.isBusy()) {     
                wait(5000); // 等 5 秒     
            }     
    
            // 從對象池向量中刪除它     
            objects.removeElement(pObj);     
        }     
    
        // 置對象池爲空     
        objects = null;     
    }     
    
    
    /**   
     * 使程序等待給定的毫秒數   
     */    
    private void wait(int mSeconds) {     
        try {     
            Thread.sleep(mSeconds);     
        }
       catch (InterruptedException e) {     
        }     
    }     
    
   
    /**   
     * 內部使用的用於保存對象池中對象的類。   
     * 此類中有兩個成員，一個是對象，另一個是指示此對象是否正在使用的標誌 。
     */    
    class PooledObject {     
    
        Object objection = null;// 對象     
        boolean busy = false; // 此對象是否正在使用的標誌，默認沒有正在使用     
    
        // 構造函數，根據一個 Object 構告一個 PooledObject 對象     
        public PooledObject(Object objection) {     
    
            this.objection = objection;     
    
        }     
    
        // 返回此對象中的對象     
        public Object getObject() {     
            return objection;     
        }     
    
        // 設置此對象的，對象     
        public void setObject(Object objection) {     
            this.objection = objection;     
    
        }     
    
        // 獲得對象對象是否忙     
        public boolean isBusy() {     
            return busy;     
        }     
    
        // 設置對象的對象正在忙     
        public void setBusy(boolean busy) {     
            this.busy = busy;     
        }     
    }     
}    
 
 
測試類：
代碼如下：
    
public class ObjectPoolTest {     
    public static void main(String[] args) throws Exception {     
        ObjectPool objPool = new ObjectPool();
    
        objPool.createPool();     
        Object obj = objPool.getObject();     
        returnObject(obj);
        objPool.closeObjectPool();     
    }     
}