设计模式之对象池模式(Object Pool Pattern)

开发 前端
对象池模式(Object Pool Pattern),是创建型设计模式的一种,将对象预先创建并初始化后放入对象池中,对象提供者就能利用已有的对象来处理请求,减少频繁创建对象所占用的内存空间和初始化时间。

[[437238]]

1 对象池模式的定义

对象池模式(Object Pool Pattern),是创建型设计模式的一种,将对象预先创建并初始化后放入对象池中,对象提供者就能利用已有的对象来处理请求,减少频繁创建对象所占用的内存空间和初始化时间。一个对象池包含一组已经初始化并且可以使用的对象,可以在有需求时创建和销毁对象。对象池的用户可以从池子中取得对象,对其进行操作处理,并在不需要时归还给池子而非直接销毁。对象池是一个特殊的工厂对象,对象池模式就是单例模式加享元模式。

2 对象池模式的应用场景

对象池模式主要适用于以下应用场景。

(1)资源受限的场景。比如,不需要可伸缩性的环境(CPU\内存等物理资源有限),CPU性能不够强劲,内存比较紧张,垃圾收集,内存抖动会造成比较大的影响,需要提高内存管理效率, 响应性比吞吐量更为重要。

(2)在内存中数量受限的对象。

(3)创建成本高的对象,可以考虑池化。

补充:常见的使用对象池的场景有在使用Socket时的各种连接池、线程池、数据库连接池等。

3 对象池模式的UML类图

对象池模式的UML类图如下图所示。

由上图可以看到,对象池模式主要包含3个角色。

(1)对象池(ObjectPool):持有对象并提供取/还等方法。

(2)抽象池化对象(PooledObject):对池中对象的抽象。

(3)具体池化对象(ConcretePoolObject):对池中对象的封装,封装对象的状态和一些其他信息。

4 对象池模式的通用写法

以下是对象池模式的通用写法。

  1. public class Client { 
  2.  
  3.     public static void main(String[] args) { 
  4.         ObjectPool pool = new ObjectPool(10,50); 
  5.         IPooledObject object = pool.borrowObject(); 
  6.         object.operation(); 
  7.         pool.returnObject(object); 
  8.         System.out.println(); 
  9.     } 
  10.  
  11.     //抽象对象 
  12.     interface IPooledObject { 
  13.         void operation(); 
  14.     } 
  15.     //具体对象 
  16.     static class ConcretePoolObject implements IPooledObject { 
  17.         public void operation() { 
  18.             System.out.println("doing"); 
  19.         } 
  20.     } 
  21.  
  22.     //对象池 
  23.     static class ObjectPool { 
  24.         private int step = 10;                      //当对象不够用的时候,每次扩容的数量 
  25.         private int minCount; 
  26.         private int maxCount; 
  27.         private Vector<IPooledObject> returneds;     //保存未借出的对象 
  28.         private Vector<IPooledObject> borroweds;     //保存已被借出的对象 
  29.  
  30.         //初始化对象池 
  31.         public ObjectPool(int minCount,int maxCount){ 
  32.             borroweds = new Vector<IPooledObject>(); 
  33.             returneds = new Vector<IPooledObject>(); 
  34.  
  35.             this.minCount = minCount; 
  36.             this.maxCount = maxCount; 
  37.  
  38.             refresh(this.minCount); 
  39.         } 
  40.  
  41.         //因为内部状态具备不变性,所以作为缓存的键 
  42.         public IPooledObject borrowObject() { 
  43.             IPooledObject next = null
  44.             if(returneds.size() > 0){ 
  45.                 Iterator<IPooledObject> i = returneds.iterator(); 
  46.                 while (i.hasNext()){ 
  47.                     next = i.next(); 
  48.                     returneds.remove(next); 
  49.                     borroweds.add(next); 
  50.                     return next
  51.                 } 
  52.             }else
  53.                 //计算出剩余可创建的对象数 
  54.                 int count = (maxCount - minCount); 
  55.                 //剩余可创建的数量大于单次固定创建的对象数 
  56.                 //则再初始化一批固定数量的对象 
  57.                 refresh(count > step ? step : count); 
  58.             } 
  59.             return next
  60.         } 
  61.  
  62.         //不需要使用的对象归还重复利用 
  63.         public void returnObject(IPooledObject pooledObject){ 
  64.             returneds.add(pooledObject); 
  65.             if(borroweds.contains(pooledObject)){ 
  66.                 borroweds.remove(pooledObject); 
  67.             } 
  68.         } 
  69.  
  70.         private void refresh(int count){ 
  71.             for (int i = 0; i < count; i++) { 
  72.                 returneds.add(new ConcretePoolObject()); 
  73.             } 
  74.         } 
  75.     } 

对象池模式和享元模式的最大区别在于,对象池模式中会多一个回收对象重复利用的方法。所以,对象池模式应该是享元模式更加具体的一个应用场景。相当于先将对象从对象池中借出,用完之后再还回去,以此保证有限资源的重复利用。

5 对象池模式的优点

复用池中对象,消除创建对象、回收对象所产生的内存开销、CPU开销,以及跨网络产生的网络开销。

6 对象池模式的缺点

(1)增加了分配/释放对象的开销。

(2)在并发环境中,多个线程可能(同时)需要获取池中对象,进而需要在堆数据结构上进行同步或者因为锁竞争而产生阻塞,这种开销要比创建销毁对象的开销高数百倍。

(3)由于池中对象的数量有限,势必成为一个可伸缩性瓶颈。

(4)很难合理设定对象池的大小,如果太小,则起不到作用;如果过大,则占用内存资源高。

 

责任编辑:姜华 来源: Tom弹架构
相关推荐

2021-12-01 07:38:27

设计模式规格模式Specificati

2019-08-16 10:46:46

JavaScript工厂模式抽象工厂模式

2013-05-23 15:59:00

线程池

2021-07-07 10:31:19

对象池模式解释器模式设计模式

2020-08-21 07:23:50

工厂模式设计

2012-08-22 10:10:25

单态单态设计设计模式

2024-02-19 08:38:34

建造者模式Android设计模式

2015-09-08 13:39:10

JavaScript设计模式

2012-01-13 15:59:07

2021-06-16 08:56:06

模版方法模式设计模式行为型设计模式

2021-06-29 08:54:23

设计模式代理模式远程代理

2023-09-04 13:14:00

装饰器设计模式

2021-12-24 07:50:45

责任链模式设计

2012-02-29 09:41:14

JavaScript

2021-06-09 08:53:34

设计模式策略模式工厂模式

2010-04-13 08:54:28

PHP设计模式命令模式

2021-06-22 15:27:13

设计模式迭代器模式Java

2023-12-13 13:28:16

装饰器模式Python设计模式

2022-03-25 11:01:28

Golang装饰模式Go 语言

2021-09-16 06:44:05

组合模式设计
点赞
收藏

51CTO技术栈公众号