对象池设计模式

在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中文网其他相关文章！