對象池模式是一種強大的設計模式，可以通過重用昂貴的對象顯著提高應用程序性能和效率。它提供了一種管理共享資源的機制，并通過限制創建的對象數量來防止資源耗盡。如果使用得當，對象池模式可以成為提高軟件應用程序的可伸縮性和可靠性的有效工具。
?前言
對象池模式是軟件開發中廣泛使用的設計模式，旨在通過重用創建成本高昂的對象來提高應用程序性能和效率。它在創建對象的新實例非常耗時且對象創建頻率很高的情況下特別有用。當可以創建的對象實例數量由于資源限制而受到限制時，此模式也很有用。
工作機制
對象池模式的工作原理是創建一個預初始化對象池，可以根據需要借用和歸還這些對象。不是每次需要時都創建一個新對象，而是在池中搜索可以重用的可用對象。如果對象可用，則將其從池中移除并返回給請求對象，否則，將創建一個新對象并將其添加到池中。
代碼實現對象池
我這邊通過使用Apache Common Pool來實現對象的池化技術。
- 引入依賴
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.9.0</version>
</dependency>
- 需要池化的對象示例
public class Foo {
private final String username;
public Foo(String username) {
this.username = username;
}
public String getUsername() {
return username;
}
}- 構建對象創建工廠 可以直接實現org.apache.commons.pool2.PooledObjectFactory<T>接口實現創建、銷毀、鈍化、取消等接口，也可以使用他的抽象類，實現創建和包裝方法即可。
public class FooPoolObjectFactory extends BasePooledObjectFactory<Foo> {
@Override
public Foo create() throws Exception {
return new Foo(String.valueOf(RandomUtils.randomInt(0, 10)));
}
@Override
public PooledObject<Foo> wrap(Foo obj) {
return new DefaultPooledObject<>(obj);
}
}- 實現驅逐策略。我們有必要定期對對象的"健康狀態"進行檢查，剔除掉"不能用"的對象，并填充新的對象給"對象池"。一般數據庫鏈接對象，要定期進行心跳，確保連接可用，如果連接斷開，需要銷毀對象，并重新創建新的對象。common-pool中，我們可以實現驅逐策略，對對象進行定期檢查。
public class FooEvictionPolicy implements EvictionPolicy<Foo> {
@Override
public boolean evict(EvictionConfig config, PooledObject<Foo> underTest, int idleCount) {
// todo 定期檢查對象某些功能是否可用
return true;
}
}- 構建&配置對象池
public GenericObjectPool<Foo> fooGenericObjectPool() {
GenericObjectPoolConfig<Foo> poolConfig = new GenericObjectPoolConfig<>();
poolConfig.setEvictionPolicy(new FooEvictionPolicy());
poolConfig.setBlockWhenExhausted(true);
poolConfig.setJmxEnabled(false);
poolConfig.setMaxWaitMillis(1000 * 10);
poolConfig.setTimeBetweenEvictionRunsMillis(60 * 1000);
poolConfig.setMinEvictableIdleTimeMillis(20 * 1000);
poolConfig.setTestWhileIdle(true);
poolConfig.setTestOnReturn(true);
poolConfig.setTestOnBorrow(true);
poolConfig.setMaxTotal(3);
// 設置拋棄策略
AbandonedConfig abandonedConfig = new AbandonedConfig();
abandonedConfig.setRemoveAbandonedOnMaintenance(true);
abandonedConfig.setRemoveAbandonedOnBorrow(true);
return new GenericObjectPool<>(new FooPoolObjectFactory(), poolConfig, abandonedConfig);
}- 獲取&歸還對象
private final GenericObjectPool<Foo> fooGenericObjectPool = fooGenericObjectPool();
public Foo borrowFoo () throws Exception {
return fooGenericObjectPool.borrowObject();
}
public void returnObject(Foo foo){
fooGenericObjectPool.returnObject(foo);
}
對象池優點
- 提高性能，對象池模式可以通過減少與對象創建和銷毀相關的開銷來顯著提高應用程序的性能。通過重用預先初始化的對象，該模式減少了需要創建的對象數量，進而減少了創建新對象所需的時間和資源。
- 資源管理，對象池模式提供了一種管理共享資源的機制，例如數據庫連接或文件句柄。通過限制創建的對象數量，該模式可以防止資源耗盡并確保資源得到有效共享。
- 一致性，對象池模式可以通過確保所有對象在使用前都預先初始化為已知狀態來幫助確保應用程序的一致性。這在對象初始化復雜或耗時的情況下特別有用。
- 易于實現，對象池模式相對容易實現，可用于多種情況。它是一種經過驗證的設計模式，已在許多應用程序和編程語言中成功使用。
對象池缺點
- 增加復雜性，對象池模式可以通過添加額外的抽象層來增加應用程序的復雜性。這會使代碼更難理解和維護，尤其是在池大小和對象生命周期管理不當的情況下。
- 開銷，雖然對象池模式可以通過減少與對象創建和銷毀相關的開銷來提高性能，但由于池本身的管理，它也會引入額外的開銷。如果池大小沒有針對應用程序的需要進行優化，這種開銷會變得很大。
- 有限的靈活性：對象池模式旨在管理一組固定的對象，可能不適合需要動態對象創建或可變池大小的應用程序。
- 線程安全，如果多個線程同時訪問池，對象池模式會引入線程安全問題。同步機制必須到位以確保一次只有一個線程可以訪問池，這可能會增加額外的開銷和代碼的復雜性。
- 資源泄漏，如果對象沒有正確返回到池中，它們可能會“泄漏”并且無法重用。隨著時間的推移，這會導致資源耗盡并降低應用程序性能。
應用場景
一般需要池化的對象往往都是比"重量級"較的對象，創建和銷毀都比較耗時，比如我們的線程，數據庫連接對象，TCP連接對象，FTP連接對象 等等，我們來具體看幾個例子把。
- Web服務器例子
Web 服務器通常需要處理大量并發請求，這會給系統資源帶來巨大壓力。通過使用對象池來管理數據庫連接、網絡套接字或其他資源，從而提高Web 服務器的性能和可擴展性，避免資源耗盡。
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketTimeoutException;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class ConnectionPool {
private static final int MAX_POOL_SIZE = 10;
private static final int MAX_WAIT_TIME = 5000; // milliseconds
private static final int PORT_NUMBER = 8080;
private final BlockingQueue<Socket> pool;
private final ServerSocket serverSocket;
public ConnectionPool() throws Exception {
pool = new ArrayBlockingQueue<>(MAX_POOL_SIZE);
serverSocket = new ServerSocket(PORT_NUMBER);
System.out.println("Server started on port " + PORT_NUMBER);
}
public Socket getConnection() throws Exception {
Socket connection = pool.poll();
if (connection == null) {
try {
connection = serverSocket.accept();
System.out.println("New connection accepted from " + connection.getInetAddress());
} catch (SocketTimeoutException e) {
System.out.println("Timeout waiting for connection. No connection found within " + MAX_WAIT_TIME + " milliseconds.");
}
}
return connection;
}
public void returnConnection(Socket connection) {
if (pool.size() < MAX_POOL_SIZE) {
pool.offer(connection);
System.out.println("Connection returned to pool. Pool size is now " + pool.size());
} else {
try {
connection.close();
System.out.println("Connection pool is full. Discarded connection.");
} catch (Exception e) {
System.out.println("Error closing discarded connection.");
}
}
}
public static void main(String[] args) throws Exception {
ConnectionPool connectionPool = new ConnectionPool();
while (true) {
Socket connection = connectionPool.getConnection();
// Do some work with the connection
Thread.sleep(5000);
connectionPool.returnConnection(connection);
}
}
}
在此示例中， ConnectionPool類用于管理到 Web 服務器的網絡連接池，構造函數將連接池初始化為最大 10 個連接，并在端口號 8080 上啟動服務器。
調用getConnection()方法可以從池中返回一個連接對象，如果池為空，則從服務器套接字接受新連接。它最多等待 5 秒以使連接可用，然后超時并返回 null。
如果池未滿，則 returnConnection ()方法將連接對象添加回池中，如果池已滿，則關閉連接并丟棄它。
在 main ()? 方法中，創建ConnectionPool對象，并在循環中重復獲取連接并返回到池中。這是對象池模式如何用于管理 Web 服務器中的連接以有效利用資源的示例。
- 游戲開發種的例子
游戲通常需要快速創建和銷毀大量對象，例如粒子、子彈或敵人。通過使用對象池來管理這些對象，游戲可以提高性能并減少與對象創建和銷毀相關的開銷。
import java.util.ArrayList;
import java.util.List;
public class GameObjectPool {
class GameObject {
public void reset() {
// reset object to default state
}
}
private static final int MAX_POOL_SIZE = 10;
private final List<GameObject> pool;
public GameObjectPool() {
pool = new ArrayList<>(MAX_POOL_SIZE);
for (int i = 0; i < MAX_POOL_SIZE; i++) {
pool.add(new GameObject());
}
}
public GameObject getObject() {
GameObject gameObject = pool.remove(0);
gameObject.reset();
return gameObject;
}
public void returnObject(GameObject gameObject) {
if (pool.size() < MAX_POOL_SIZE) {
pool.add(gameObject);
}
}
public static void main(String[] args) {
GameObjectPool gameObjectPool = new GameObjectPool();
// Use game objects from pool
GameObject gameObject1 = gameObjectPool.getObject();
// modify gameObject1
gameObjectPool.returnObject(gameObject1);
GameObject gameObject2 = gameObjectPool.getObject();
// modify gameObject2
gameObjectPool.returnObject(gameObject2);
}
}
在此示例中，GameObjectPool?類用于管理游戲開發場景中的GameObject?對象池。構造函數將池初始化為最大大小 10，并創建GameObject對象來填充池。
調用getObject ()?方法從池中移除一個對象，并在返回之前將其重置為默認狀態。如果池未滿，則 returnObject ()方法將一個對象添加回池中。
在 main ()?方法中，創建 GameObjectPool對象并重復獲取游戲對象并返回到池中。這是對象池模式如何用于管理游戲開發場景中的游戲對象以有效利用資源的示例。
總結
總之，對象池模式是一種強大的設計模式，可以通過重用昂貴的對象顯著提高應用程序性能和效率。它提供了一種管理共享資源的機制，并通過限制創建的對象數量來防止資源耗盡。如果使用得當，對象池模式可以成為提高軟件應用程序的可伸縮性和可靠性的有效工具。
