对象池模式

2025年8月18日 | 阅读 5 分钟

对象池模式
对象池 DP 的优势
对象池 DP 的用法
对象池 DP 的 UML
对象池 DP 的示例

通常，性能是软件开发中的关键问题，而对象创建可能是一个代价高昂的步骤。

对象池模式说“重用创建成本高的对象”。

基本上，对象池是一个容器，其中包含指定数量的对象。当从池中取出一个对象时，该对象在放回之前在池中不可用。池中的对象具有生命周期：创建、验证和销毁。

池有助于更好地管理可用资源。有很多使用示例：特别是在应用服务器中，有数据源池、线程池等。

对象池设计模式的优势

它显着提高了应用程序的性能。
在类实例的初始化率很高的情况下，它最有效。
它管理连接并提供重用和共享它们的方法。
它还可以限制可以创建的最大对象数。

用途

当应用程序需要创建成本高的对象时。例如：需要打开太多的数据库连接，那么创建新连接需要很长时间，并且数据库服务器将过载。
当有几个客户端需要在不同的时间需要相同的资源时。

注意：对象池设计模式本质上用于服务器的 Web 容器中，用于创建线程池和数据源池来处理请求。

对象池模式示例

让我们通过给定的 UML 图来理解该示例。

对象池模式的 UML

上述 UML 的实现

步骤 1

创建一个 ObjectPool 类，用于创建多个对象。

文件：ObjectPool.java

import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public abstract class ObjectPool<T> {
/*
  pool implementation is based on ConcurrentLinkedQueue from the java.util.concurrent package.
  ConcurrentLinkedQueue is a thread-safe queue based on linked nodes. 
   Because the queue follows FIFO technique (first-in-first-out).
 */        
	
   private ConcurrentLinkedQueue<T> pool;
       
 /*	
  
   ScheduledExecutorService starts a special task in a separate thread and observes
   the minimum and maximum number of objects in the pool periodically in a specified 
    time (with parameter validationInterval). 
   When the number of objects is less than the minimum, missing instances will be created. 
   When the number of objects is greater than the maximum, too many instances will be removed. 
   This is sometimes useful for the balance of memory consuming objects in the pool.
*/
    private ScheduledExecutorService executorService;
       /*
     * Creates the pool.
     *
     * @param minObjects : the minimum number of objects residing in the pool
     */
     
    public ObjectPool(final int minObjects) 
    {
        // initialize pool
    	
        initialize(minObjects);
        
    }
    
    /*
      Creates the pool.
      @param minObjects:   minimum number of objects residing in the pool.
      @param maxObjects:   maximum number of objects residing in the pool.
      @param validationInterval: time in seconds for periodical checking of 
         minObjects / maxObjects conditions in a separate thread.
      When the number of objects is less than minObjects, missing instances will be created.
      When the number of objects is greater than maxObjects, too many instances will be removed.
    */
     public ObjectPool(final int minObjects, final int maxObjects, final long validationInterval) {
        // initialize pool
         initialize(minObjects);
          // check pool conditions in a separate thread
        executorService = Executors.newSingleThreadScheduledExecutor();
        executorService.scheduleWithFixedDelay(new Runnable()  // annonymous class
        {
            @Override
            public void run() {
                int size = pool.size();
               
                if (size < minObjects) {
                    int sizeToBeAdded = minObjects + size;
                    for (int i = 0; i < sizeToBeAdded; i++) {
                        pool.add(createObject());
                    }
                } else if (size > maxObjects) {
                    int sizeToBeRemoved = size - maxObjects;
                    for (int i = 0; i < sizeToBeRemoved; i++) {
                        pool.poll();
                    }
                }
            }
        }, validationInterval, validationInterval, TimeUnit.SECONDS);
    }
    
  /*
      Gets the next free object from the pool. If the pool doesn't contain any objects,
      a new object will be created and given to the caller of this method back.
     
      @return T borrowed object
  */
    public T borrowObject() {
        T object;
        if ((object = pool.poll()) == null)
        {
            object = createObject();
        }
        return object;
    }
 /*
      Returns object back to the pool.
      @param object object to be returned
  */
    public void returnObject(T object) {
        if (object == null) {
            return;
        }
        this.pool.offer(object);
    }
   /*
        Shutdown this pool.
    */
      public void shutdown(){
        if (executorService != null){
            executorService.shutdown();
        }
    }
    /*
        Creates a new object.
         @return T new object
     */
    protected abstract T createObject();

    private void initialize(final int minObjects)  {
        pool = new ConcurrentLinkedQueue<T>();
        for (int i = 0; i < minObjects; i++) {
            pool.add(createObject());
        }
    }
}// End of the ObjectPool Class.

步骤 2

创建一个 ExportingProcess 类，该类将由 ExportingTask 类使用。

文件：ExportingProcess.java

public class ExportingProcess {
 private long processNo;

    public ExportingProcess(long processNo)  {
         this.processNo = processNo;
        // do some  expensive calls / tasks here in future
        // .........
      System.out.println("Object with process no. " + processNo + " was created");
     }
   
    public long getProcessNo() {
        return processNo;
    }
}// End of the ExportingProcess class.

步骤 3

创建一个 ExportingTask 类，它将使用 ExportingProcess 和 ObjectPool 类。

文件：ExportingTask.java

public class ExportingTask implements Runnable {
	    private ObjectPool<ExportingProcess> pool;
	    private int threadNo;
	    public ExportingTask(ObjectPool<ExportingProcess> pool, int threadNo){
	        this.pool = pool;
	        this.threadNo = threadNo;
	    }
    
	    public void run() {
	        // get an object from the pool
	    	ExportingProcess exportingProcess = pool.borrowObject();
	        System.out.println("Thread " + threadNo + ": Object with process no. "
                    + exportingProcess.getProcessNo() + " was borrowed");

	        //you can  do something here in future
	        // .........

               // return ExportingProcess instance back to the pool
	        pool.returnObject(exportingProcess);

	        System.out.println("Thread " + threadNo +": Object with process no. "
                   + exportingProcess.getProcessNo() + " was returned");
	    }

	}// End of the ExportingTask class. 

步骤 4

创建一个 ObjectPoolDemo 类。

文件：ObjectPoolDemo.java

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
public class ObjectPoolDemo{
	  private ObjectPool<ExportingProcess> pool;
	  private AtomicLong processNo=new AtomicLong(0);
	  public void setUp() {
         	// Create a pool of objects of type ExportingProcess.
	       /*Parameters:
             1) Minimum number of special ExportingProcess instances residing in the pool = 4
             2) Maximum number of special ExportingProcess instances residing in the pool = 10
             3) Time in seconds for periodical checking of minObjects / maxObjects conditions
                in a separate thread = 5.
             -->When the number of ExportingProcess instances is less than minObjects, 
                 missing instances will be created.
             -->When the number of ExportingProcess instances is greater than maxObjects,
                  too many instances will be removed.
            -->If the validation interval is negative, no periodical checking of 
                  minObjects / maxObjects conditions in a separate thread take place.
              These boundaries are ignored then.
           */
      pool = new ObjectPool<ExportingProcess>(4, 10, 5)
        {
            protected ExportingProcess createObject()
            {
                // create a test object which takes some time for creation
                return new ExportingProcess( processNo.incrementAndGet());
            }
        };
    }
    public void tearDown() {
        pool.shutdown();
    }
    public void testObjectPool() {
      	ExecutorService executor = Executors.newFixedThreadPool(8);

        // execute 8 tasks in separate threads
        
        executor.execute(new ExportingTask(pool, 1));
        executor.execute(new ExportingTask(pool, 2));
        executor.execute(new ExportingTask(pool, 3));
        executor.execute(new ExportingTask(pool, 4));
        executor.execute(new ExportingTask(pool, 5));
        executor.execute(new ExportingTask(pool, 6));
        executor.execute(new ExportingTask(pool, 7));
        executor.execute(new ExportingTask(pool, 8));

        executor.shutdown();
        try {
            executor.awaitTermination(30, TimeUnit.SECONDS);
            } catch (InterruptedException e)
            
              {
               e.printStackTrace();
              }
    }
    public static void main(String args[])  { 
    	ObjectPoolDemo op=new ObjectPoolDemo();
    	op.setUp();
    	op.tearDown();
    	op.testObjectPool();
   } 
}//End of the ObjectPoolDemo class.

下载此对象池模式示例

输出

下一个主题结构型设计模式

← 上一个下一个 →

对象池模式

对象池设计模式的优势

用途

注意：对象池设计模式本质上用于服务器的 Web 容器中，用于创建线程池和数据源池来处理请求。

对象池模式示例

对象池模式的 UML

上述 UML 的实现

步骤 1

步骤 2

步骤 3

步骤 4

输出

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

设计模式

J2EE 模式

表示层

对象池模式

对象池设计模式的优势

用途

注意：对象池设计模式本质上用于服务器的 Web 容器中，用于创建线程池和数据源池来处理请求。

对象池模式示例

对象池模式的 UML

上述 UML 的实现

步骤 1

步骤 2

步骤 3

步骤 4

输出

相关帖子

迭代器模式

中介者模式

享元模式

策略模式

Java 设计模式

备忘录模式

原型模式

抽象工厂模式

桥接模式

命令模式

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器