Java对象池技术的原理和实现

作者:神秘网友 发布时间:2021-02-28 13:50:07

Java对象池技术的原理和实现

1、前言 单例模式是限制了一个类只能有一个实例,对象池模式则是限制一个类实例的个数。对象池类就像是一个对象管理员,它以Static列表(也就是装对象的池子)的形式存存储某个实例数受限的类的实例,每一个实例还要加一个标记,标记该实例是否被占用。当类初始化的时候,这个对象池就被初始化了,实例就被创建出来。然后,用户可以向这个类索取实例,如果池中所有的实例都已经被占用了,那么抛出异常。用户用完以后,还要把实例“还”回来,即释放占用。 对象池类的成员应该都是静态的。用户也不应该能访问池子里装着的对象的构造函数,以防用户绕开对象池创建实例。书上说这个模式会用在数据库连接的管理上。比如,每个用户的连接数是有限的,这样每个连接就是一个池子里的一个对象,“连接池”类就可以控制连接数了。 恰当地使用对象池技术,能有效地改善应用程序的性能。目前,对象池技术已得到广泛的应用,如对于网络和数据库连接这类重量级的对象,一般都会采用对象池技术。但在使用对象池技术时也要注意如下问题:
  • 并非任何情况下都适合采用对象池技术。基本上,只在重复生成某种对象的操作成为影响性能的关键因素的时候,才适合采用对象池技术。而如果进行池化所能带来的性能提高并不重要的话,还是不采用对象池化技术为佳,以保持代码的简明。
  • 要根据具体情况正确选择对象池的实现方式。如果是创建一个公用的对象池技术实现包,或需要在程序中动态指定所池化对象的Class类型时,才选择通用对象池。而大部分情况下,采用专用对象池就可以了。
2、Java对象的生命周期分析 Java对象的生命周期大致包括三个阶段:对象的创建,对象的使用,对象的清除。因此,对象的生命周期长度可用如下的表达式表示:T = T1 + T2 +T3。其中T1表示对象的创建时间,T2表示对象的使用时间,而T3则表示其清除时间。由此,我们可以看出,只有T2是真正有效的时间,而T1、T3则是对象本身的开销。下面再看看T1、T3在对象的整个生命周期中所占的比例。 我们知道,Java对象是通过构造函数来创建的,在这一过程中,该构造函数链中的所有构造函数也都会被自动调用。另外,默认情况下,调用类的构造函数时,Java会把变量初始化成确定的值:所有的对象被设置成null,整数变量(byte、short、int、long)设置成0,float和double变量设置成0.0,逻辑值设置成false。所以用new关键字来新建一个对象的时间开销是很大的,如表所示。
运算操作 示例 标准化时间
本地赋值 i = n 1.0
实例赋值 this.i = n 1.2
方法调用 Funct() 5.9
新建对象 New Object() 980
新建数组 New int[10] 3100
从上表可以看出,新建一个对象需要980个单位的时间,是本地赋值时间的980倍,是方法调用时间的166倍,而若新建一个数组所花费的时间就更多了。 再看清除对象的过程。我们知道,Java语言的一个优势,就是Java程序员勿需再像C/C++程序员那样,显式地释放对象,而由称为垃圾收集器(Garbage Collector)的自动内存管理系统,定时或在内存凸现出不足时,自动回收垃圾对象所占的内存。凡事有利总也有弊,这虽然为Java程序设计者提供了极大的方便,但同时它也带来了较大的性能开销。这种开销包括两方面,首先是对象管理开销,GC为了能够正确释放对象,它必须监控每一个对象的运行状态,包括对象的申请、引用、被引用、赋值等。其次,在GC开始回收“垃圾”对象时,系统会暂停应用程序的执行,而独自占用CPU。 因此,如果要改善应用程序的性能,一方面应尽量减少创建新对象的次数;同时,还应尽量减少T1、T3的时间,而这些均可以通过对象池技术来实现。 3、对象池技术的基本原理 对象池技术基本原理的核心有两点:缓存和共享,即对于那些被频繁使用的对象,在使用完后,不立即将它们释放,而是将它们缓存起来,以供后续的应用程序重复使用,从而减少创建对象和释放对象的次数,进而改善应用程序的性能。事实上,由于对象池技术将对象限制在一定的数量,也有效地减少了应用程序内存上的开销。 实现一个对象池,一般会涉及到如下的类: 1)对象池工厂(ObjectPoolFactory)类,该类主要用于管理相同类型和设置的对象池(ObjectPool),它一般包含如下两个方法:
  • createPool:用于创建特定类型和设置的对象池;
  • destroyPool:用于释放指定的对象池;
同时为保证ObjectPoolFactory的单一实例,可以采用Singleton设计模式,见下述getInstance方法的实现:
public static ObjectPoolFactory getInstance() {
 if (poolFactory == null) {
  poolFactory = new ObjectPoolFactory();
 }
 return poolFactory;
} 
2)参数对象(ParameterObject)类:该类主要用于封装所创建对象池的一些属性参数,如池中可存放对象的数目的最大值(maxCount)、最小值(minCount)等。 3)对象池(ObjectPool)类:用于管理要被池化对象的借出和归还,并通知PoolableObjectFactory完成相应的工作。它一般包含如下两个方法:
  • getObject:用于从池中借出对象;
  • returnObject:将池化对象返回到池中,并通知所有处于等待状态的线程;
4)池化对象工厂(PoolableObjectFactory)类:该类主要负责管理池化对象的生命周期,就简单来说,一般包括对象的创建及销毁。该类同ObjectPoolFactory一样,也可将其实现为单实例。 4、通用对象池的实现 对象池的构造和管理可以按照多种方式实现。最灵活的方式是将池化对象的Class类型在对象池之外指定,即在ObjectPoolFactory类创建对象池时,动态指定该对象池所池化对象的Class类型,其实现代码如下:
. . .
public ObjectPool createPool(ParameterObject paraObj,Class clsType) {
 return new ObjectPool(paraObj, clsType);
}
. . .

其中,paraObj参数用于指定对象池的特征属性,clsType参数则指定了该对象池所存放对象的类型。对象池(ObjectPool)创建以后,下面就是利用它来管理对象了,具体实现如下:

public class ObjectPool {
 private ParameterObject paraObj;//该对象池的属性参数对象
 private Class clsType;//该对象池中所存放对象的类型
 private int currentNum = 0; //该对象池当前已创建的对象数目
 private Object currentObj;//该对象池当前可以借出的对象
 private Vector pool;//用于存放对象的池
 public ObjectPool(ParameterObject paraObj, Class clsType) {
  this.paraObj = paraObj;
  this.clsType = clsType;
  pool = new Vector();
 }
 public Object getObject() {
  if (pool.size() = paraObj.getMinCount()) {
   if (currentNum = paraObj.getMaxCount()) {
    //如果当前池中无对象可用,而且已创建的对象数目小于所限制的最大值,就利用
    //PoolObjectFactory创建一个新的对象
    PoolableObjectFactory objFactory =PoolableObjectFactory.getInstance();
    currentObj = objFactory.create Object (clsType);
    currentNum++;
   } else {
    //如果当前池中无对象可用,而且所创建的对象数目已达到所限制的最大值,
    //就只能等待其它线程返回对象到池中
    synchronized (this) {
     try {
      wait();
     } catch (InterruptedException e) {
      System.out.println(e.getMessage());
      e.printStackTrace();
     }
     currentObj = pool.firstElement();
    }
   }
  } else {
   //如果当前池中有可用的对象,就直接从池中取出对象
   currentObj = pool.firstElement();
  }
  return currentObj;
}
  public void returnObject(Object obj) {
   // 确保对象具有正确的类型
   if (obj.isInstance(clsType)) {
    pool.addElement(obj);
    synchronized (this) {
     notifyAll();
    }
   } else {
    throw new IllegalArgumentException("该对象池不能存放指定的对象类型");
   }
  }
}

从上述代码可以看出,ObjectPool利用一个java.util.Vector作为可扩展的对象池,并通过它的构造函数来指定池化对象的Class类型及对象池的一些属性。在有对象返回到对象池时,它将检查对象的类型是否正确。当对象池里不再有可用对象时,它或者等待已被使用的池化对象返回池中,或者创建一个新的对象实例。不过,新对象实例的创建并不在ObjectPool类中,而是由PoolableObjectFactory类的createObject方法来完成的,具体实现如下:

. . .
public Object createObject(Class clsType) {
 Object obj = null;
 try {
  obj = clsType.newInstance();
 } catch (Exception e) {
  e.printStackTrace();
 }
 return obj;
}
. . .

这样,通用对象池的实现就算完成了,下面再看看客户端(Client)如何来使用它,假定池化对象的Class类型为StringBuffer:

. . .
//创建对象池工厂
ObjectPoolFactory poolFactory = ObjectPoolFactory. getInstance ();
//定义所创建对象池的属性
ParameterObject paraObj = new ParameterObject(2,1);
//利用对象池工厂,创建一个存放StringBuffer类型对象的对象池
ObjectPool pool = poolFactory.createPool(paraObj, StringBuffer.class);
//从池中取出一个StringBuffer对象
StringBuffer buffer = (StringBuffer)pool.getObject();
//使用从池中取出的StringBuffer对象
buffer.append("hello");
System.out.println(buffer.toString());
. . .

可以看出,通用对象池使用起来还是很方便的,不仅可以方便地避免频繁创建对象的开销,而且通用程度高。但遗憾的是,由于需要使用大量的类型定型(cast)操作,再加上一些对Vector类的同步操作,使得它在某些情况下对性能的改进非常有限,尤其对那些创建周期比较短的对象。

5、专用对象池的实现      由于通用对象池的管理开销比较大,某种程度上抵消了重用对象所带来的大部分优势。为解决该问题,可以采用专用对象池的方法。即对象池所池化对象的Class类型不是动态指定的,而是预先就已指定。这样,它在实现上也会较通用对象池简单些,可以不要ObjectPoolFactory和PoolableObjectFactory类,而将它们的功能直接融合到ObjectPool类,具体如下(假定被池化对象的Class类型仍为StringBuffer,而用省略号表示的地方,表示代码同通用对象池的实现):
public class ObjectPool {
 private ParameterObject paraObj;//该对象池的属性参数对象
 private int currentNum = 0; //该对象池当前已创建的对象数目
 private StringBuffer currentObj;//该对象池当前可以借出的对象
 private Vector pool;//用于存放对象的池
 public ObjectPool(ParameterObject paraObj) {
  this.paraObj = paraObj;
  pool = new Vector();
 }
 public StringBuffer getObject() {
  if (pool.size() = paraObj.getMinCount()) {
   if (currentNum = paraObj.getMaxCount()) {
    currentObj = new StringBuffer();
    currentNum++;
   }
   . . .
  }
  return currentObj;
 }
 public void returnObject(Object obj) {
  // 确保对象具有正确的类型
  if (StringBuffer.isInstance(obj)) {
   . . .
  }
}
6、Java对象池示例 对象池使用的基本思路是:将用过的对象保存起来,等下一次需要这种对象的时候,再拿出来重复使用,从而在一定程度上减少频繁创建对象所造成的开销。 并非所有对象都适合拿来池化,因为维护对象池也要造成一定开销。对生成时开销不大的对象进行池化,反而可能会出现“维护对象池的开销”大于“生成新对象的开销”,从而使性能降低的情况。但是对于生成时开销可观的对象,池化技术就是提高性能的有效策略了。下面是构建对象池的一个例子:
import java.util.Enumeration;
import java.util.Vector;
 
 
/**
* Copyright@www.jrliu.com.
* Author:jrliu
* Date:2020/10/30
* Description:对象池实现
*/
public class Objectpool {
    /**
     * 内部使用的用于保存对象池中对象的类。
     * 此类中有两个成员,一个是对象,另一个是指示此对象是否正在使用的标志 。
     */
    class PooledObject {
        Object object = null;// 对象
        boolean busy = false; // 此对象是否正在使用的标志,默认没有正在使用
        // 构造函数,根据一个 Object 构告一个 PooledObject 对象
        public PooledObject(Object object) {
            this.object = object;
        }
        public Object getObject(){
            return object;
        }
        // 设置此对象的,对象
        public void setObject(Object object) {
            this.object = object;
        }
        // 获得对象对象是否忙
        public boolean isBusy() {
            return busy;
        }
 
        // 设置对象的对象正在忙
        public void setBusy(boolean busy) {
            this.busy = busy;
        }
    }
 
    private int numObjects = 10; // 对象池的大小
    private int maxObjects = 50; // 对象池最大的大小
    private VectorPooledObject objects = null; //存放对象池中对象的向量( PooledObject类型)
 
    public Objectpool() {
    }
 
    /*** 创建一个对象池***/
    public synchronized void createPool() {
        // 确保对象池没有创建。如果创建了,保存对象的向量 objects 不会为空
        if (objects != null) {
            return; // 如果己经创建,则返回
        }
        // 创建保存对象的向量 , 初始时有 0 个元素
        objects = new Vector();
        // 根据 numObjects 中设置的值,循环创建指定数目的对象
        for (int x = 0; x  numObjects; x++) {
            if ((objects.size() == 0)  this.objects.size()  this.maxObjects) {
                Object obj = new Object();
                objects.addElement(new PooledObject(obj));
            }
        }
    }
public synchronized Object getObject() { // 确保对象池己被创建 if (objects == null) { return null; // 对象池还没创建,则返回 null } Object conn = getFreeObject(); // 获得一个可用的对象 // 如果目前没有可以使用的对象,即所有的对象都在使用中 while (conn == null) { wait(250); conn = getFreeObject(); // 重新再试,直到获得可用的对象,如果 // getFreeObject() 返回的为 null,则表明创建一批对象后也不可获得可用对象 } return conn;// 返回获得的可用的对象 } /** * 本函数从对象池对象 objects 中返回一个可用的的对象,如果 * 当前没有可用的对象,则创建几个对象,并放入对象池中。 * 如果创建后,所有的对象都在使用中,则返回 null */ private Object getFreeObject() { // 从对象池中获得一个可用的对象 Object obj = findFreeObject(); if (obj == null) { //如果目前对象池中没有可用的对象,创建一些对象 createObjects(); // 重新从池中查找是否有可用对象 obj = findFreeObject(); // 如果创建对象后仍获得不到可用的对象,则返回 null if (obj == null) { return null; } } return obj; } private void createObjects(){ Object obj = new Object(); PooledObject pooledObject = new PooledObject(obj); objects.add(pooledObject); } /** * 查找对象池中所有的对象,查找一个可用的对象, * 如果没有可用的对象,返回 null */ private Object findFreeObject() { Object obj = null; PooledObject pObj = null; // 获得对象池向量中所有的对象 Enumeration enumerate = objects.elements(); // 遍历所有的对象,看是否有可用的对象 while (enumerate.hasMoreElements()) { pObj = (PooledObject) enumerate.nextElement(); // 如果此对象不忙,则获得它的对象并把它设为忙 if (!pObj.isBusy()) { obj = pObj.getObject(); pObj.setBusy(true); } } return obj;// 返回找到到的可用对象 } /** * 此函数返回一个对象到对象池中,并把此对象置为空闲。 * 所有使用对象池获得的对象均应在不使用此对象时返回它。 */ public void returnObject(Object obj) { // 确保对象池存在,如果对象没有创建(不存在),直接返回 if (objects == null) { return; } PooledObject pObj = null; Enumeration enumerate = objects.elements(); // 遍历对象池中的所有对象,找到这个要返回的对象对象 while (enumerate.hasMoreElements()) { pObj = (PooledObject) enumerate.nextElement(); // 先找到对象池中的要返回的对象对象 if (obj == pObj.getObject()) { // 找到了 , 设置此对象为空闲状态 pObj.setBusy(false); break; } } } /** * 关闭对象池中所有的对象,并清空对象池。 */ public synchronized void closeObjectPool() { // 确保对象池存在,如果不存在,返回 if (objects == null) { return; } PooledObject pObj = null; Enumeration enumerate = objects.elements(); while (enumerate.hasMoreElements()) { pObj = (PooledObject) enumerate.nextElement(); // 如果忙,等 5 秒 if (pObj.isBusy()) { wait(5000); // 等 5 秒 } // 从对象池向量中删除它 objects.removeElement(pObj); } // 置对象池为空 objects = null; } /** * 使程序等待给定的毫秒数 */ private void wait(int mSeconds) { try { Thread.sleep(mSeconds); } catch (InterruptedException e) { } } public static void main(String[] args) throws Exception { Objectpool objPool = new Objectpool(); objPool.createPool(); Object obj = objPool.getObject(); objPool.returnObject(obj); objPool.closeObjectPool(); } }

 

Java对象池技术的原理和实现 相关文章

  1. Java面向对象(类与对象的关系,创建与初始化对象,创建对象内存分析,简单小结类与对象)

    类与对象的关系 ◆ 类是一种抽象的数据类型,它是对某一类事物整体描述/定义,但是并不能代表某一个具体的事物。 动物、植物、手机、电脑 ....... Person 类、Pet类、car 类等,这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为。 ◆ 对象是抽

  2. java中的自增自减和幂方写法

    java中的自增自减和幂方写法 java中的自增 a++或++a public class Demo4 { public static void main(String[] args) { int a = 3; int b = a++; //++相当于a=a+1,但是a++是先给b赋值(b=未加时的a=3),在加减 System.out.println(a); //4 a已经加过了1所以是4

  3. jquery对象与Dom对象

    !DOCTYPE htmlhtmlhead meta charset="utf-8" titlejquery对象与Dom对象/title/headbodyinput type="button" value="点我" id="btn"script type="text/javascript" src="jquery.js"/scriptscript type="text/javascript" // console.log( document.getElemen

  4. Java(10):用户交互Scanner

    Scanner Java.util.Scanner是Java5的新特征,我们可以通过Scanner类来获取用户的输入。 基本语法: Scanner s = new Scanner(System.in); 通过Scanner类的next()和nextLine()方法获取输入的字符串,在读取前我们一般需要使用hasNext()与hasNextLine()判断是

  5. Java网络编程UDP通信原理

    前言 继续今天我们的Java网络编程——TCP和UDP通信 一、TCP和UDP概述 传输层通常以TCP和UDP协议来控制端点与端点的通信 TCP UDP 协议名称 传输控制协议 用户数据包协议 是否连接 面向连接的协议。数据必须要建立连接 无连接的协议,每个数据报中都给出完整的

  6. Java线程池

    利用Executors创建不同的线程池满足不同场景的需求 线程池的创建方式:Java基础二、多线程 1、Fork/Join框架 把大任务分割成若干小任务并行执行,最终汇总每个小任务结果后得到大任务结果的框架。 2、Work-Stealing算法 : 某个线程从其他队列里窃取任务来执

  7. javascript正则表达式学习笔记

    使用规则 用//包裹语句\b 单词边界* 转义\g 全文搜索m换行搜索i 忽略大小写lastIndex 是当前表达式匹配内容的最后一个字符的下一个位置source 正则表达式的文本字符串字符类 泛指 [abc] 把a或b或c归为一类(匹配abc中任意一种) 取反^ [^abc]范围类 [a-z] 匹

  8. java的基础知识

    编写一个hello,world public class Hello{ public static void main(String[] arge){ System.out.print("hello,world"); } } public class(这个表示一个类,修饰符的意思)Hello是类的名字 pubic static void (这些是修饰符,关键字)main(主方法)(String[]

  9. LeetCode——66. 加一(Java)

    题目介绍 题干:给定一个由 整数 组成的 非空 数组所表示的非负整数,在该数的基础上加一。最高位数字存放在数组的首位, 数组中每个元素只存储单个数字。你可以假设除了整数 0 之外,这个整数不会以零开头。示例1:输入:digits = [1,2,3]输出:[1,2,4]解释

  10. AES php java 互转

    php phpclass AesCrypt{ //初始化向量 private $iv = '84195bd96a8a2e7f'; //Mcrypt算法 private $cipher = MCRYPT_RIJNDAEL_128; //Mcrypt支持的加密模型 特别适用于对文件进行加密。 相比 ECB, 它的安全性有明显提升。 private $mode = MCRYPT_MODE_CBC;

每天更新java,php,javaScript,go,python,nodejs,vue,android,mysql等相关技术教程,教程由网友分享而来,欢迎大家分享IT技术教程到本站,帮助自己同时也帮助他人!

Copyright 2020, All Rights Reserved. Powered by 跳墙网(www.tqwba.com)|网站地图|关键词