Java對象池示例

   單例模式是限制了一個類只能有一個實例，對象池模式則是限制一個類實例的個數。對象池類就像是一個對象管理員，它以Static列表（也就是裝對象的池子）的形式存存儲某個實例數受限的類的實例，每一個實例還要加一個標記，標記該實例是否被占用。當類初始化的時候，這個對象池就被初始化了，實例就被創建出來。然后，用戶可以向這個類索取實例，如果池中所有的實例都已經被占用了，那么拋出異常。用戶用完以后，還要把實例“還”回來，即釋放占用。對象池類的成員應該都是靜態的。用戶也不應該能訪問池子里裝著的對象的構造函數，以防用戶繞開對象池創建實例。書上說這個模式會用在數據庫連接的管理上。比如，每個用戶的連接數是有限的，這樣每個連接就是一個池子里的一個對象，“連接池”類就可以控制連接數了。

Java對象的生命周期分析

　　Java對象的生命周期大致包括三個階段：對象的創建，對象的使用，對象的清除。因此，對象的生命周期長度可用如下的表達式表示：T = T1 + T2 +T3。其中T1表示對象的創建時間，T2表示對象的使用時間，而T3則表示其清除時間。由此，我們可以看出，只有T2是真正有效的時間，而T1、T3則是對象本身的開銷。下面再看看T1、T3在對象的整個生命周期中所占的比例。

　　我們知道，Java對象是通過構造函數來創建的，在這一過程中，該構造函數鏈中的所有構造函數也都會被自動調用。另外，默認情況下，調用類的構造函數時，Java會把變量初始化成確定的值：所有的對象被設置成null，整數變量（byte、short、int、long）設置成0，float和 double變量設置成0.0，邏輯值設置成false。所以用new關鍵字來新建一個對象的時間開銷是很大的，如表1所示。

　　表1 一些操作所耗費時間的對照表

　　從表1可以看出，新建一個對象需要980個單位的時間，是本地賦值時間的980倍，是方法調用時間的166倍，而若新建一個數組所花費的時間就更多了。

　　再看清除對象的過程。我們知道，Java語言的一個優勢，就是Java程序員勿需再像C/C++程序員那樣，顯式地釋放對象，而由稱為垃圾收集器（Garbage Collector）的自動內存管理系統，定時或在內存凸現出不足時，自動回收垃圾對象所占的內存。凡事有利總也有弊，這雖然為Java程序設計者提供了極大的方便，但同時它也帶來了較大的性能開銷。這種開銷包括兩方面，首先是對象管理開銷，GC為了能夠正確釋放對象，它必須監控每一個對象的運行狀態，包括對象的申請、引用、被引用、賦值等。其次，在GC開始回收“垃圾”對象時，系統會暫停應用程序的執行，而獨自占用CPU。

　　因此，如果要改善應用程序的性能，一方面應盡量減少創建新對象的次數；同時，還應盡量減少T1、T3的時間，而這些均可以通過對象池技術來實現。

　　對象池技術的基本原理

　　對象池技術基本原理的核心有兩點：緩存和共享，即對于那些被頻繁使用的對象，在使用完后，不立即將它們釋放，而是將它們緩存起來，以供后續的應用程序重復使用，從而減少創建對象和釋放對象的次數，進而改善應用程序的性能。事實上，由于對象池技術將對象限制在一定的數量，也有效地減少了應用程序內存上的開銷。

對象池使用的基本思路是：

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

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

commons-pool提供了一套很好用的對象池組件。使用也很簡單，不過對一些簡單的對象使用對象池就沒必要了。

ObjectPool定義了一個簡單的池化接口，有三個對應實現
GenericObjectPool：實現了可配置的后進先出或先進先出(LIFO/FIFO)行為，默認是作為一個后進先出隊列，這意味當對象池中有可用的空閑對象時，borrowObject 將返回最近的對象實例，如果將lifo 屬性設置為false，則按FIFO行為返回對象實例。
StackObjectPool ：實現了后進先出(LIFO)行為。
SoftReferenceObjectPool： 實現了后進先出(LIFO)行為。另外，對象池還在SoftReference 中保存了每個對象引用，允許垃圾收集器針對內存需要回收對象。

KeyedObjectPool定義了一個以任意的key訪問對象的接口（可以池化對種對象），有兩種對應實現。
GenericKeyedObjectPool ：實現了先進先出(FIFO)行為。
StackKeyedObjectPool ： 實現了后進先出(LIFO)行為。

PoolableObjectFactory 定義了池化對象的生命周期方法，我們可以使用它分離被池化的不同對象和管理對象的創建，持久，銷毀。
BasePoolableObjectFactory這個實現PoolableObjectFactory 接口的一個抽象類，我們可用擴展它實現自己的池化工廠。

一個對象池使用的簡單例子：

package tf;

import org.apache.commons.pool.BasePoolableObjectFactory;
import org.apache.commons.pool.ObjectPool;
import org.apache.commons.pool.impl.StackObjectPool;

public class Pool {

    public static void main(String[] args) throws Exception {
        ObjectPool pool = new StackObjectPool(new UserFactory());
        User u = (User) pool.borrowObject(); // 從池中借出一個對象
        u.setName("me");
        u.sayHello();
        pool.returnObject(u); // 歸還對象
    }

    static class UserFactory extends BasePoolableObjectFactory {
        /**
         * 產生一個新對象
         */
        public Object makeObject() {
            return new User();
        }

        /**
         * 還原對象狀態
         */
        public void passivateObject(Object obj) {
            User u = (User) obj;
            u.clear();
        }
    }

    static class User {
        String name;

        void setName(String name) {
            this.name = name;
        }

        void sayHello() {
            System.out.println("hello, " + name);
        }

        void clear() {
            name = "";
        }
    }
}