java对象池

首先介绍下对象池，所谓的对象池就是存储一部分对象到一个池中，需要时就取，不需要时候就释放，其实对象池中维护的是两个SparseArray。

那么对象池有什么用呢，当然是有用的，假设一个场景，在消息处理的时候，比如聊天软件中每个消息都不停的创建和销毁那么这样一来就会给GC造成很大的压力，此时此刻对象池就可以派上用场了，其实在这里我们可以联想到线程池。

首先我们看对象池ObjectPool，这是一个抽象的方法，其中创建对象的方法留给开发者自己去创建。

注意下面的手敲上去的，不是复制的，可能有些格式错误，读者注意领悟其中的思想

public abstract class ObjectPool<T>{
//空闲池，用户需要时是从这个池中拿到数据
private SparseArray<T> freePool;
//正在使用的吃，用户正在使用这个池中的对象
private SparseArray<T> lentPool;
//池的大小
private int maxCapacity;
public ObjectPool(int initialCapacity,int maxCapacity){
initialize(initialCapacity);
this.maxCapacity = maxCapacity;
}
public ObjectPoo(int initialCapacity){
//初始化两个数组
lentPool = new SparseArray<>();
freePool = new SparseArray<>();
//如果对象池中的数量小于初始化的值，那么就需要创建对象到SparseArray中去
for(int i = 0; i<initialCapacity;i++){
	freePool.put(i,create())
}

}
/**
*申请对象
*/
public T acquire() throws Exception{
T t = null;
//个这个数组上锁，防止多个用户对其进行操作
synchronized(freePool){
	int freeSize = freePool.size();
	for(int i=0;i<freeSize;i++)
	{
		int key = freePool.keyAt(i);
		t = freePool.get(key);
		if(t!=null){
		//在空闲的数组中移除这个对象，在正在使用的数组中增加这个对象
			this.lentPool.put(key,t);
			this.freePool.remove(key);
			return t;
			}
     }
     //程序执行到这里，说明程序在空闲数组中找不到对象了，现在就需要进行判断，目前对象池中所有的对象之和是否大于设置的最大值，如果不大于这需要重新创建对象，并将这个对象添加到正在使用的SparseArray中去
     if(t==null && lentPool.size()+freeSize<maxCapacity){
//这里可以自己处理
if(lenPool.size()+freeSize == maxCapacity){
'		throw new Exception()
	}
	t = create();
	lentPool.put(lentPool,size()+freeSize,t);
}
 }
 return t;                    
}
//回收对象
public void release(T t){
	if(t ==null){
		return;
	}
	int key = lentPool.indexOfValue(t);
	//释放前可以将这个对象返回给用户，目前这个没有实现
	restore(t);
	this,freePool.put(key,t);
	this,lentPool.remove(key);
}
    public ObjectPool(int maxCapacity) {
        this(maxCapacity/2,maxCapacity);
    }

protected abstract T create();
protected  void restore(T t){ };

}

MyObject

public class MyObjectPool extends ObjectPool{
    public MyObjectPool(int initialCapacity, int maxCapacity) {
        super(initialCapacity, maxCapacity);
    }

    public MyObjectPool(int maxCapacity) {
        super(maxCapacity);
    }
	//在这定义对象的类型
    @Override
    protected Object create() {//LRU
        return new Object();
    }
    //在这里释放对象
     @Override
    public void release(Object o) {
        super.release(o);
    }
}

使用

	   //定义两个参数
        MyObjectPool pool = new MyObjectPool(2,4);
        //从freePool中取
        Object o1 = pool.acquire();
        Object o2 = pool.acquire();
        Object o3 = pool.acquire();
        Object o4 = pool.acquire();
        //只能取到4个 因为限制了最大为4
        System.out.println("hb==="+o1.hashCode());
        System.out.println("hb==="+o2.hashCode());
        pool.release(o1);
        pool.release(o2);