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;     
            }     
        }     
    }     


/**   
     * 關閉對象池中所有的對象，並清Null 物件池。   
*/    
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();     
    }     
}