小巧的对象池Pools
AndroidX的核心库中有一个util工具包，里面有一个用于创建对象池的帮助类：Pools。简短的一百行代码呈现了一个标准对象池的实现。
1、Pool<T>接口
从源码中看见官方标准的对象池接口定义Pool<T>。
/**
* 用于管理对象池的接口。
*
* @param <T> The pooled type.
*/
public interface Pool<T> {
/**
* @return 返回对象池中的一个实例，或者null.
*/
@Nullable
T acquire();
/**
* 将实例释放到池中。
*
* @param instance 要释放的实例。
* @return 是否将实例放入池中：true放入，false未放入。
*
* @throws IllegalStateException 如果实例已经在池中抛出异常。
*/
boolean release(@NonNull T instance);
}2、实现对象池
基于上面定义的Pool接口，实现对象池，这对于程序员来说是基本功。看看框架的是怎么实现的。
2.1、SimplePool
最简单的对象池实现SimplePool如下：构造方法中传入对象池大小maxPoolSize，用来初始化固定大小的数组mPool，数组用来存放对象。
/**
* Simple (non-synchronized) pool of objects.
*
* @param <T> The pooled type.
*/
public static class SimplePool<T> implements Pool<T> {
private final Object[] mPool;
private int mPoolSize;
/**
* Creates a new instance.
*
* @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];
}
//从对象池中取出对象复用，如果没有则返回null
@Override
public T acquire() {
if (mPoolSize > 0) {
final int lastPooledIndex = mPoolSize - 1;
T instance = (T) mPool[lastPooledIndex];
mPool[lastPooledIndex] = null;
mPoolSize--;
return instance;
}
return null;
}
//简单的数组数据结构+1
@Override
public boolean release(@NonNull T instance) {
if (isInPool(instance)) {
throw new IllegalStateException("Already in the pool!");
}
if (mPoolSize < mPool.length) {
mPool[mPoolSize] = instance;
mPoolSize++;
return true;
}
return false;
}
//遍历instance对象是否已经在数组池mPool中
private boolean isInPool(@NonNull T instance) {
for (int i = 0; i < mPoolSize; i++) {
if (mPool[i] == instance) {
return true;
}
}
return false;
}
}2.2、SynchronizedPool
上面的SimplePool对象池并非线程安全，多线程情况下可能会出现溢出或者重复使用同一个对象。如何修改呢？最简答快速的完善是继承SimplePool给acquire()和release(T element)方法添加同步锁synchronized，即可实现同步对象池SynchronizedPool：
/**
* Synchronized) pool of objects.
*
* @param <T> The pooled type.
*/
public static class SynchronizedPool<T> extends SimplePool<T> {
//创建一个对象锁
private final Object mLock = new Object();
/**
* Creates a new instance.
*
* @param maxPoolSize The max pool size.
*
* @throws IllegalArgumentException If the max pool size is less than zero.
*/
public SynchronizedPool(int maxPoolSize) {
super(maxPoolSize);
}
//从对象池中获取对象的时候加锁
@Override
public T acquire() {
synchronized (mLock) {
return super.acquire();
}
}
//释放对象到对象池中也加锁，避免多线程写而造成数组溢出
@Override
public boolean release(@NonNull T element) {
synchronized (mLock) {
return super.release(element);
}
}
}参考资料：
Docs > Reference > Pools">Android Developers > Docs > Reference > Pools
Docs > Reference > Pools.SimplePool">Android Developers > Docs > Reference > Pools.SimplePool
