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 一些操作所耗費時間的對照表
|
運算操作 |
示例 |
標準化時間 |
|
本地賦值 |
i = n |
1.0 |
|
實例賦值 |
this.i = n |
1.2 |
|
方法調用 |
Funct() |
5.9 |
|
新建對象 |
New Object() |
980 |
|
新建數組 |
New int[10] |
3100 |
從表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 = "";
}
}
}