JAVA 实现 对象池代码

最新推荐文章于 2021-11-29 19:18:50 发布
最新推荐文章于 2021-11-29 19:18:50 发布
阅读量515 收藏
点赞数
分类专栏： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/x_ky/article/details/79651862
版权
参考http://blog.csdn.net/shimiso/article/details/9814917

进行代码调整和验证测试，欢迎拍砖


对象池使用的基本思路是：

将用过的对象保存起来，等下一次需要这种对象的时候，再拿出来重复使用，从而在一定程度上减少频繁创建对象所造成的开销。 并非所有对象都适合拿来池化――因为维护对象池也要造成一定开销。对生成时开销不大的对象进行池化，反而可能会出现“维护对象池的开销”大于“生成新对象的开销”，从而使性能降低的情况。但是对于生成时开销可观的对象，池化技术就是提高性能的有效策略了。下面是构建对象池的一个例子：


ObjectPool类代码

import java.util.Enumeration;
import java.util.Vector;

// 对象池 xuky 2018.03.22
// 参考http://blog.csdn.net/shimiso/article/details/9814917
// 调整代码Bug，调整为整体的单例对象
public class ObjectPool {
	private volatile static ObjectPool uniqueInstance;

	Boolean PRINT_MSG = true;
	private int numObjects = 10; // 对象池的大小
	private int maxObjects = 50; // 对象池最大的大小
	private Vector<PooledObject> OBJECTS = null; // 存放对象池中对象的向量( PooledObject类型)

	public static ObjectPool getInstance() {
		if (uniqueInstance == null) {
			synchronized (ObjectPool.class) {
				if (uniqueInstance == null) {
					// 双重检查加锁
					uniqueInstance = new ObjectPool();
				}
			}
		}
		return uniqueInstance;
	}

	/**
	 * 内部使用的用于保存对象池中对象的类。 此类中有两个成员，一个是对象，另一个是指示此对象是否正在使用的标志 。
	 */
	class PooledObject {
		Object objection = null;// 对象
		boolean busy = false; // 此对象是否正在使用的标志，默认没有正在使用
		// 构造函数，根据一个 Object 构告一个 PooledObject 对象

		public PooledObject(Object objection) {
			this.objection = objection;
		}

		// 返回此对象中的对象
		public Object getObject() {
			return objection;
		}

		// 设置此对象的，对象
		public void setObject(Object objection) {
			this.objection = objection;
		}

		// 获得对象对象是否忙
		public boolean isBusy() {
			return busy;
		}

		// 设置对象的对象正在忙
		public void setBusy(boolean busy) {
			this.busy = busy;
		}
	}

	private ObjectPool() {
		createPool();
	}

	/*** 创建一个对象池 ***/
	private synchronized void createPool() {
		// 确保对象池没有创建。如果创建了，保存对象的向量 objects 不会为空
		if (OBJECTS != null) {
			return; // 如果己经创建，则返回
		}

		// 创建保存对象的向量 , 初始时有 0 个元素
		OBJECTS = new Vector<PooledObject>();

		// 根据 numObjects 中设置的值，循环创建指定数目的对象
		for (int x = 0; x < numObjects; x++) {
			// xuky 2018.03.22 原始代码中的if判断有问题
			// if ((OBJECTS.size() == 0) && (OBJECTS.size() < 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(incrementalObjects); // 如果目前对象池中没有可用的对象，创建一些对象、
			// xuky 创建一些对象，放在对象池中
			addObjToPool();

			// 重新从池中查找是否有可用对象
			obj = findFreeObject();

			// 如果创建对象后仍获得不到可用的对象，则返回 null
			if (obj == null) {
				return null;
			}
		}

		return obj;
	}

	private void addObjToPool() {
		if (OBJECTS == null)
			createPool();

		if (PRINT_MSG)
			System.out.println("addObjToPool");

		if (OBJECTS.size() < maxObjects) {
			Object obj = new Object();
			OBJECTS.addElement(new PooledObject(obj));
		}

	}

	/**
	 * 查找对象池中所有的对象，查找一个可用的对象， 如果没有可用的对象，返回 null
	 */
	private Object findFreeObject() {

		Object obj = null;
		PooledObject pObj = null;

		// 获得对象池向量中所有的对象
		Enumeration<PooledObject> enumerate = OBJECTS.elements();

		// 遍历所有的对象，看是否有可用的对象
		int i = 1;
		while (enumerate.hasMoreElements()) {
			pObj = (PooledObject) enumerate.nextElement();

			if (PRINT_MSG)
				System.out.println("findFreeObject 遍历(" + i + ") " + pObj);
			i++;

			// 如果此对象不忙，则获得它的对象并把它设为忙
			if (!pObj.isBusy()) {
				if (PRINT_MSG)
					System.out.println("PooledObject is free" + pObj);
				obj = pObj.getObject();
				pObj.setBusy(true);
				// xuky 2018.03.22 如果找到了就退出查找的循环
				break;
			}
		}

		return obj;// 返回找到到的可用对象
	}

	/**
	 * 此函数返回一个对象到对象池中，并把此对象置为空闲。 所有使用对象池获得的对象均应在不使用此对象时返回它。
	 */

	public void returnObject(Object obj) {

		// 确保对象池存在，如果对象没有创建（不存在），直接返回
		if (OBJECTS == null) {
			return;
		}

		PooledObject pObj = null;

		Enumeration<PooledObject> enumerate = OBJECTS.elements();

		// 遍历对象池中的所有对象，找到这个要返回的对象对象
		while (enumerate.hasMoreElements()) {
			pObj = (PooledObject) enumerate.nextElement();

			// 先找到对象池中的要返回的对象对象
			if (obj == pObj.getObject()) {
				// 找到了 , 设置此对象为空闲状态
				pObj.setBusy(false);
				break;
			}
		}
	}

	public void setNewObject(Object obj, Object newObj) {

		// 确保对象池存在，如果对象没有创建（不存在），直接返回
		if (OBJECTS == null) {
			return;
		}

		PooledObject pObj = null;

		Enumeration<PooledObject> enumerate = OBJECTS.elements();

		// 遍历对象池中的所有对象，找到这个要返回的对象对象
		while (enumerate.hasMoreElements()) {
			pObj = (PooledObject) enumerate.nextElement();

			// 先找到对象池中的要返回的对象对象
			if (obj == pObj.getObject()) {
				// 找到了 , 设置此对象为空闲状态
				pObj.setObject(newObj);
				break;
			}
		}
	}

	/**
	 * 关闭对象池中所有的对象，并清空对象池。
	 */
	public synchronized void closeObjectPool() {

		// 确保对象池存在，如果不存在，返回
		if (OBJECTS == null) {
			return;
		}

		PooledObject pObj = null;

		Enumeration<PooledObject> enumerate = OBJECTS.elements();

		int i = 1;
		while (enumerate.hasMoreElements()) {

			pObj = (PooledObject) enumerate.nextElement();

			if (PRINT_MSG)
				System.out.println("removeElement(" + i + ")" + pObj);

			i++;

			// 如果忙，等 5 秒
			if (pObj.isBusy()) {
				// wait(5000); // 等 5 秒
				wait(1000); // xuky 等 1 秒
			}

			// 从对象池向量中删除它

			OBJECTS.removeElement(pObj);

			// xuky 2018.03.22 必须添加这里的代码，否则遍历时会访问不到一些节点
			// 一旦删除后，将会导致顺序(链表)信息错误
			enumerate = OBJECTS.elements();
		}

		// 置对象池为空
		OBJECTS = null;
	}

	/**
	 * 使程序等待给定的毫秒数
	 */
	private void wait(int mSeconds) {
		try {

			if (PRINT_MSG)
				System.out.println("sleep " + mSeconds);

			Thread.sleep(mSeconds);
		} catch (InterruptedException e) {
		}
	}
}

测试类代码

public class ObjectPoolTest {


	public static void main(String[] args) throws Exception {
		class TestData{
			String data1,data2;
			public TestData(String d1,String  d2){
				data1 = d1;
				data2 = d2;
			}
		}

		// 1、对象池 实例获取
		ObjectPool objPool = ObjectPool.getInstance();

		Object obj = null;
		for( int i = 0;i<10;i++ ){
			// 2、从对象池中获取对象
			obj = objPool.getObject();
			System.out.println(obj);
		}

		// 3、向对象池中归还对象
		objPool.returnObject(obj);
		System.out.println("returnObject");

		obj = objPool.getObject();
		System.out.println(obj);

		obj = objPool.getObject();
		System.out.println(obj);

		objPool.returnObject(obj);
		System.out.println("returnObject");

		obj = objPool.getObject();
		System.out.println(obj);

		TestData td = new TestData("1","2");

		// 4、修改对象池中的某个对象
		objPool.setNewObject(obj, td);

		// 试验是否可以释放修改后的对象
		objPool.returnObject(td);

		// 5、从对象池中释放所有对象
//		objPool.closeObjectPool();
	}
}

x_ky
关注
专栏目录
【SpringBoot】34、SpringBoot整合Redis实现序列化存储Java对象
Asurplus
10-23 21万+
前面我们已经介绍过【SpringBoot】十七、SpringBoot 中整合 Redis，我们可以看出，在 SpringBoot 对 Redis 做了一系列的自动装配，使用还是非常方便的 一、背景 1、思考‘ 通过我们前面的学习，我们已经可以往 Redis 中存入字符串，那么我们要往 Redis 中存入 Java 对象该怎么办呢？ 2、方案 我们可以将 Java 对象转化为 JSON 对象，然后转为 JSON 字符串，存入 Redis，那么我们从 Redis 中取出该数据的时候，我们也只能取出字符串，并转
java 通用对象池的实现
ai_xiangjuan的博客
04-01 1431
本文以apache common-pools为例 主要组成类 PooledObject（可被池化的对象) 默认实现DefaultPooledObject，里面封装了一个真正的用户需要池化的对象object。 其中DefaultPooledObject里面有两个方法: Exception borrowedBy ：用于记录上次调用borrow时的堆栈，用于跟踪代码调用情...
Java对象池实现源码
08-29
java对象池轻量级实现，借鉴“Jakarta Commons Pool”组件实现思想。
java池模式_JAVA模式 对象池 简要代码示例
weixin_39704314的博客
02-18 88
package org.rui.util;import java.util.ArrayList;/*** 对象复用模式** @author PC**/public class PoolManager{//连接池对象public static class PoolItem{boolean inUse = false;Object item;//池数据PoolItem(Object item){thi...
对象池详细代码
qq_42725795的博客
05-09 210
public static TurretManager instance; private Dictionary<string, List<GameObject>> pool; void Awake() { instance = this; } void Start() { //string为预设体的name，list存入预设体生成的gameobject ...
Java对象池技术的原理及其实现
06-05
Java对象池技术的原理及其实现
简单实现对象池
qq_36029999的博客
10-21 432
对象池的关键代码： public class ObjectPoolManager { // 多一对象池 private Dictionary> dicPools; // #region 单例 private static ObjectPoolManager instance; public static ObjectPoolManager I
基于java的对象池实现.zip
最新发布
03-24
本教程将深入探讨如何在Java中实现一个简单的对象池。 首先，我们需要定义对象池的基本结构。一个对象池通常包含两个主要部分：存储池中对象的数据结构（例如数组或集合）以及管理这些对象的方法。在Java中，我们...
举例讲解Java设计模式中的对象池模式编程
09-02
在Java中实现对象池模式，通常包括以下几个关键部分： 1. **Reusable**：对象池中的对象应该是可重复使用的，这意味着它们的状态可以被重置，以便再次分配给其他客户端。 2. **Client**：对象池的使用者，即从池中...
Java对象池的简单实现
doom20082004的博客
12-12 2783
1. 对象池 当调用对象时，不使用常规的new 构造子的方式，而是通过一个对象池操作。 即如果池中存在该对象，则取出；如果不存在，则新建一个对象并存储在池中。当使用完该对象后，则将该对象的归还给对象池。 这里会存在几个问题，必须注意。 Tips 1，考虑多线程状态下的存取对象； Tips 2，考虑将对象池目录表设计为Singleton模式，这样使得内存中仅存在唯一的一份缓存对象的表。
java设计模式之实现对象池模式示例分享
09-04
对象池模式经常用在频繁创建、销毁对象（并且对象创建、销毁开销很大）的场景，比如数据库连接池、线程池、任务队列池等。本代码简单，没有限制对象池大小
Unity3d对象池源代码
10-15
Unity3d对象池源代码免费下载！
Java 设计模式系列(7) —— 对象池模式
qq_38219153的博客
01-04 257
对象池模式 对象的示例化是最耗费性能的操作之一，这在过去是一个大问题，现在我们不用再过于关注它。当我们处理封装外部资源时，对象的创建操作则会耗费很多资源。 解决方案是重用和共享这些创建成本高昂的对象，这称为对象池模式 对象池模式的参与者： ResourcePool (资源池类)： 用于封装逻辑的类，用来保存和管理资源列表 Resource (资源类): 用于封装特定资源的类。资源类通常被池资源引用，因此只要资源池不重新分配，他们就永远不会回收。 Client (客户端类)：使用资源的类 对象池模式的简
Java对象池
qq_44601070的博客
11-29 357
Java对象池
Java对象池示例
N的专栏
11-17 2441
单例模式是限制了一个类只能有一个实例，对象池模式则是限制一个类实例的个数。对象池类就像是一个对象管理员，它以Static列表（也就是装对象的池子）的形式存存储某个实例数受限的类的实例，每一个实例还要加一个标记，标记该实例是否被占用。当类初始化的时候，这个对象池就被初始化了，实例就被创建出来。然后，用户可以向这个类索取实例，如果池中所有的实例都已经被占用了，那么抛出异常。用户用完以后，还要把实例“还
实现一个对象池模式（注册树）
weixin_44320900的博客
07-07 136
    在一些项目架构当中，当我们需要实例化一大堆的类，比如 a/b/c/d/e/f/g…等等，那么代码变得很冗余，那么有没有一种方法，能够去避免这种方法呢？（其实是因为懒）      下面讲解的是一种能够解决这种情况的设计模式。对象池模式(又叫注册树模式) ：     对象池模式(The Object Pool Pattern)是单例模式的一个变种，它提供了获取一系列相同对象实例的入口。
java池技术_Java对象池技术的原理及其实现
weixin_31517893的博客
02-20 124
public class ObjectPool { 　private ParameterObject paraObj;//该对象池的属性参数对象 　private Class clsType;//该对象池中所存放对象的类型 　private int currentNum = 0; //该对象池当前已创建的对象数目 　private Object currentObj;//该对象池当前可以借出的对象...
java timetasker_Java网络与多线程系列之1：实现一个简单的对象池
weixin_32315511的博客
02-24 151
前言为什么要从对象池开始呢，先从一个网络IO操作的demo说起比如下面这段代码，显而易见已经在代码中使用了一个固定大小的线程池，所以现在的重点在实现Runnble接口的匿名对象上，这个对象每次创建线程都要重复创建。假设有个提供http服务的程序，每天要处理几万，上百万等等的用户请求，那么我们的程序岂不是每次请求都会创建一次Runnble的实现对象？这种大量重复创建同一个对象显然会造成大量的内存资源...
Java连接池实现详解与步骤
连接池的概念基于对象池设计模式，它管理一组可重用的数据库连接，遵循“获取—使用—归还”的原则。在Java中，有多种实现连接池的方式，包括： 1. **JDBC-ODBC桥连接**：这是一种基础的连接方式，通过Java的JDBC ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值