前言
对象缓存池很多地方都用到，比比皆是。主要是供后续的应用程序重复使用，从而减少创建对象和释放对象的次数，进而改善应用程序的性能。
比如在：AsyncLayoutInflater的使用：
布局异步（AsyncLayoutInflater）加载中,对于AsyncLayoutInflater.InflateRequest的对象缓存。
public AsyncLayoutInflater.InflateRequest obtainRequest() {
//这里使用了对象缓存
AsyncLayoutInflater.InflateRequest obj = mRequestPool.acquire();
if (obj == null) {
obj = new AsyncLayoutInflater.InflateRequest();
}
return obj;
}
使用方法
来源官方class上面的的使用介绍，recycle(),这里可以对实例对象进行清洁，意思是初始化里面的字段，也可以不清洁，看需求吧。AsyncLayoutInflater实例对象缓存中的就做了初始化，再缓存实例对象，代码如下：
public void releaseRequest(InflateRequest obj) {
//重置一下实例对象
obj.callback = null;
obj.inflater = null;
obj.parent = null;
obj.resid = 0;
obj.view = null;
mRequestPool.release(obj);
}
使用方法，如下：
public class MyPooledClass {
private static final SynchronizedPool<MyPooledClass> sPool =
new SynchronizedPool<MyPooledClass>(10);
public static MyPooledClass obtain() {
MyPooledClass instance = sPool.acquire();
return (instance != null) ? instance : new MyPooledClass();
}
public void recycle() {
// Clear state if needed.
sPool.release(this);
}
}
Pool接口的定义
来让我们看看这个Pool的接口，接口很简单，就2个方法。 acquire()主要是从缓存池中获取一个对象，这里可能为空。为空的情况：
1，对象缓存池中没有缓存对象，这种情况是对象池中没有放进任何对象。
2，对象池中对象被用完了。
release() 主要是释放一个对象到对象缓存池中，如果这个对象已经存在缓存池中，会抛出异常，如果缓存对象池已满，则返回false,不做任何操作。
public interface Pool<T> {
/**从缓存池中返回一个对象，可能为空。
* @return An instance from the pool if such, null otherwise.
*/
@Nullable
T acquire();
/**
* Release an instance to the pool.
*释放一个对象到对象缓存池中
* @param instance The instance to release.
* 对象实例是否放入对象缓存池中
* @return Whether the instance was put in the pool.
*如果这个对象已经存在缓存池中，会抛出异常
* @throws IllegalStateException If the instance is already in the pool.
*/
boolean release(@NonNull T instance);
}
SimplePool的源码
具体的实现逻辑在SimplePool，但这里没有加锁，如需要加锁，使用SynchronizedPool即可。 缓存大小mPoolSize必须大于0，否则抛出异常。 调用acquire()时候，先判断mPoolSize是否大于0： 如果小于0，返回null。 如果大于0，证明对象池中还有可用对象，然后取一个使用，这个对象从数组中移出（后面release会把它再加回来，觉得这里设计好巧妙）。mPoolSize减一。返回缓存实例。
调用release(),会先调用isInPool()判断这个对象是否存在数组中，存在就抛出异常。因为acquire()时候已经把它移出了。主要防止一个对象重复保存到数组中，操作同一对象发生未知异常。 然后判断pool是否已满，如果没有存满，缓存一个对象，mPoolSize加一。如果存满，直接返回false。下面是SimplePool的源码。
public static class SimplePool<T> implements Pool<T> {
//线程池对象数组
private final Object[] mPool;
//线程池目前可用对象size，意思是还存在多少个对象在数组中。
private int mPoolSize;
/**
* Creates a new instance.
* 最大对象池size
* @param maxPoolSize The max pool size.
* @throws IllegalArgumentException If the max pool size is less than zero.
*/
public SimplePool(int maxPoolSize) {
if (maxPoolSize <= 0) {
throw new IllegalArgumentException("The max pool size must be > 0");
}
mPool = new Object[maxPoolSize];
}
public T acquire() {
//判断 mPoolSize ，判断对象池是否已经用完了。用完了返回null
if (mPoolSize > 0) {
//取一个下标
final int lastPooledIndex = mPoolSize - 1;
//取出一个对象
T instance = (T) mPool[lastPooledIndex];
//把这个对象从数组中移出（后面release会把它再加回来）觉得这里设计好巧妙。
mPool[lastPooledIndex] = null;
//下标减1，意思是已经拿走一个去使用了。
mPoolSize--;
//返回对象
return instance;
}
//对象池用完了，返回null，让上层自己去新建一个吧
return null;
}
@Override
public boolean release(@NonNull T instance) {
//主要防止一个对象重复保存到数组中，判断这个对象是否存在数组中，存在就抛出异常。
//因为acquire()时候已经把它移出了。
if (isInPool(instance)) {
throw new IllegalStateException("Already in the pool!");
}
//如果没有存满，缓存一个对象。
if (mPoolSize < mPool.length) {
//把上面从数组中移出对象，再次保存回来。（移出保存是同一个哦）毕竟不是一次性的。
mPool[mPoolSize] = instance;
//池子大小加一
mPoolSize++;
return true;
}
//存满了，返回false ,这个上层可以针对这个做对应逻辑。
return false;
}
private boolean isInPool(@NonNull T instance) {
//查找这个对象是否存在数组中
for (int i = 0; i < mPoolSize; i++) {
if (mPool[i] == instance) {
return true;
}
}
return false;
}
}
如果需要同步
使用SynchronizedPool即可。
来让我们看看大致的流程图
流程图，丑是丑了点，将就看看吧！ 
想要深入了解更多Android进阶知识与资料可以叫入粉丝交流群：872206502
如果文章对您有一点帮助的话，希望您能点一下赞，您的点赞，是我前进的动力
