java对象池

太过爱你忘了你带给我的痛 2022-10-02 01:54 213阅读 0赞

首先介绍下对象池，所谓的对象池就是存储一部分对象到一个池中，需要时就取，不需要时候就释放，其实对象池中维护的是两个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);