物件池設計模式

在Java编程中经常使用的一种软件设计模式是物件池設計模式。该模式控制了对象池中的对象如何被创建和销毁。

使用物件池設計模式来管理对象的生产和销毁。该模式的概念是积累可重用的对象，而不是每次需要时都创建新的对象。对于生产新对象成本显著的情况，例如网络连接、数据库连接或昂贵的对象，Java程序员经常使用物件池設計模式。

对象池设计的语法

在Java中，物件池設計模式的语法如下所示−

• 创建一个固定大小的对象集合。

• 初始化池的项目。

• 跟踪当前在池中的项目。

• 每当需要时，请检查池中是否有可访问的对象。

• 请确保及时自行检索池中的任何可用对象，并根据需要适当地归还它们

• 然而，如果当前在该储存器中没有可用的项目 - 我们请求立即创建一个新项目，以免浪费时间或资源，然后将其重新投入流通。

对象池设计的不同算法

Java物件池設計模式可用于各种算法。以下是三种可能的策略，每种策略都有独特的代码实现：

延迟初始化和同步

import java.util.ArrayList;
import java.util.List;

public class ObjectPool {
   private static ObjectPool instance;
   private List<Object> pool = new ArrayList<>();
   private int poolSize;

   private ObjectPool() {}
   
   public static synchronized ObjectPool getInstance(int poolSize) {
      if (instance == null) {
         instance = new ObjectPool();
         instance.poolSize = poolSize;
         for (int i = 0; i < poolSize; i++) {
            instance.pool.add(createObject());
         }
      }
      return instance;
   }

   private static Object createObject() {
      // Create and return a new object instance
      return new Object();
   }

   public synchronized Object getObject() {
      if (pool.isEmpty()) {
         return createObject();
      } else {
         return pool.remove(pool.size() - 1);
      }
   }

   public synchronized void releaseObject(Object object) {
      if (pool.size() < poolSize) {
         pool.add(object);
      }
   }
}

The technique used here emphasizes thread safety through initialization of an accordingly lazy and synchronized object pool with preset capacity limitations that are amendable to expansion. Empty pools result in safe new instance production, while non-full instances are carefully reintroduced to maintain proper operational integrity.

使用并发数据结构的渴望初始化

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class ObjectPool {
   private static final int POOL_SIZE = 10;
   private static ObjectPool instance = new ObjectPool();
   private BlockingQueue<Object> pool = new LinkedBlockingQueue<>(POOL_SIZE);

   private ObjectPool() {
      for (int i = 0; i < POOL_SIZE; i++) {
         pool.offer(createObject());
      }
   }

   private static Object createObject() {
      // Create and return a new object instance
      return new Object();
   }

   public static ObjectPool getInstance() {
      return instance;
   }

   public Object getObject() throws InterruptedException {
      return pool.take();
   }

   public void releaseObject(Object object) {
      pool.offer(object);
   }
}

在这个实现中，使用了一个静态的final实例变量来急切地初始化对象池。底层数据结构是一个LinkedBlockingQueue，它提供了线程安全而无需同步的功能。在初始化过程中，对象被添加到池中，并在需要时使用take()从队列中检索它们。当一个项目被释放时，使用offer()将其重新排队。

基于时间的过期

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;

public class ObjectPool {
   private static final int POOL_SIZE = 10;
   private static ObjectPool instance = new ObjectPool();
   private BlockingQueue<Object> pool = new LinkedBlockingQueue<>(POOL_SIZE);

   private ObjectPool() {}

   private static Object createObject() {
      // Create and return a new object instance
      return new Object();
   }

   public static ObjectPool getInstance() {
      return instance;
   }

   public Object getObject() throws InterruptedException {
      Object object = pool.poll(100, TimeUnit.MILLISECONDS);
      if (object == null) {
         object = createObject();
      }
      return object;
   }

   public void releaseObject(Object object) {
      pool.offer(object);
   }

}

这个版本中的对象池采用了基于时间的过期机制，而不是固定大小。当需要一个对象时，使用poll()函数从池中取出对象，在没有可用对象时，该函数会等待一段时间后返回null。对象是按需生成的。如果没有对象存在，将生成一个新的对象并返回。当一个对象被释放时，使用offer()将其放回池中。根据提供的超时值，expireObjects()函数用于从池中移除过期的项。

使用物件池設計模式的不同方法

Java的物件池設計模式可以以多种方式实现。下面是两种典型的方法，包括代码示例和结果−

方法1：简单的物件池設計模式

一种构建简单而实用的对象池的方法是采用基于数组的方法。这种方法的工作原理如下：一旦完全生成，所有对象都被包含在相应的“池”数组中以备将来使用；在运行时，会检查该集合以确定是否有所需的任何项目可用。如果可以从现有库存中获取，将立即返回；否则，将根据需求生成另一个新的对象。

Example

public class ObjectPool {
   private static final int POOL_SIZE = 2;
   private static List<Object> pool = new ArrayList<Object>(POOL_SIZE);
    
   static {
      for(int i = 0; i < POOL_SIZE; i++) {
         pool.add(new Object());
      }
   }
    
   public static synchronized Object getObject() {
      if(pool.size() > 0) {
         return pool.remove(0);
      } else {
         return new Object();
      }
   }
    
   public static synchronized void releaseObject(Object obj) {
      pool.add(obj);
   }
}

Example

public class ObjectPoolExample {
   public static void main(String[] args) {
      Object obj1 = ObjectPool.getObject();
      Object obj2 = ObjectPool.getObject();
        
      System.out.println("Object 1: " + obj1.toString());
      System.out.println("Object 2: " + obj2.toString());
        
      ObjectPool.releaseObject(obj1);
      ObjectPool.releaseObject(obj2);
        
      Object obj3 = ObjectPool.getObject();
      Object obj4 = ObjectPool.getObject();
        
      System.out.println("Object 3: " + obj3.toString());
      System.out.println("Object 4: " + obj4.toString());
   }
}

输出

Object 1: java.lang.Object@4fca772d
Object 2: java.lang.Object@1218025c
Object 3: java.lang.Object@4fca772d
Object 4: java.lang.Object@1218025c

方法二：通用物件池設計模式

使用列表作为基础，这种技术方便构建一个标准的对象池，将对象存储在集合中，直到它们完全被生成并包含在集合中。每当需要访问一个项目时，系统会浏览池中的可用选项。如果有一个可用选项，则足够使用；但如果没有可用选项，则必须创建另一个新项目。

Example

import java.util.ArrayList;
import java.util.List;

public class ObjectPool<T> {
   private List<T> pool;
    
   public ObjectPool(List<T> pool) {
      this.pool = pool;
   }
    
   public synchronized T getObject() {
      if (pool.size() > 0) {
         return pool.remove(0);
      } else {
         return createObject();
      }
   }
    
   public synchronized void releaseObject(T obj) {
      pool.add(obj);
   }
    
   private T createObject() {
      T obj = null;
      // create object code here
      return obj;
   }
    
   public static void main(String[] args) {
      List<String> pool = new ArrayList<String>();
      pool.add("Object 1");
      pool.add("Object 2");
        
      ObjectPool<String> objectPool = new ObjectPool<String>(pool);
        
      String obj1 = objectPool.getObject();
      String obj2 = objectPool.getObject();
        
      System.out.println("Object 1: " + obj1);
      System.out.println("Object 2: " + obj2);
        
      objectPool.releaseObject(obj1);
      objectPool.releaseObject(obj2);
        
      String obj3 = objectPool.getObject();
      String obj4 = objectPool.getObject();
        
      System.out.println("Object 3: " + obj3);
      System.out.println("Object 4: " + obj4);
   }
}

输出

Object 1: Object 1
Object 2: Object 2
Object 3: Object 1
Object 4: Object 2

使用类级锁的最佳实践

当生产新对象的成本较高时，Java程序员经常使用物件池設計模式。典型的使用场景包括 −

网络连接

In a Java program, network connections may be managed using the Object Pool Design Pattern. It is preferable to reuse existing connections from a pool rather than having to create new ones every time one is required. This may enhance the application's functionality while lightening the burden on the network server.

数据库连接

与网络连接管理类似，Java应用程序也可以使用物件池設計模式来处理数据库连接。最好是从池中重用现有的连接，而不是每次需要数据库连接时都创建新的连接。这可以提高应用程序的性能，减轻数据库服务器的负担。

執行緒池

使用Java程式的開發人員應該採用物件池設計模式來有效管理執行緒池。與根據需要重新建立每個所需的執行緒不同，良好策劃的使用依賴於重複使用指定工作群組中可用的預先存在的執行緒。因此，它透過保持由該結構的效率驅動的執行緒創建和終止過程的開銷較低來鼓勵最佳應用程式效能。

影像處理

在處理Java程式中的密集影像處理任務時，值得考慮實作物件池設計模式。透過利用來自專用池的預先存在的對象，您可以加快應用程式的效能，同時減少照片編輯任務的整體運算需求。

檔案系統操作

如果你在Java應用程式中面臨繁重的影像處理任務，值得考慮應用物件池設計模式。這種技術利用特定池中的現有項目來提高程式的輸出速度，並減少編輯照片所需的計算資源。

結論

物件池設計模式是Java程式設計中的一種有用的設計模式，適用於建立新物件成本較高的情況。它提供了一種控制可重複使用物件供應的方式，降低了創建新產品的總成本。簡單物件池或通用物件池是實現物件池設計模式的兩個範例。物件池設計模式通常應用於Java程式設計中處理昂貴對象，如資料庫連接和網路連線。它在目的上與享元模式和單例模式類似，但有不同的用途。

以上是物件池設計模式的詳細內容。更多資訊請關注PHP中文網其他相關文章！