在Android开发中，创建实例是一个最基本的操作，因为我们是面向对象的语言嘛~
手机设备搭建的是一个很敏感的操作系统，稍有不注意，内存便会疯涨，就会频繁的引发GC扫描、回收垃圾，造成UI卡顿，比如大量的创建实例就会如此。
但是在开发过程中，我们避免不了new Object，如果某个需求，需要创建大量的临时对象，怎么处理比较合适呢？这就是我们这篇文章所要说的实例缓存池-Pools。
Pools类是放在support v4包的util目录下，从包名可以看得出来，这是一个工具类，没有任何依赖，代码逻辑也非常简单，一个接口两个实现。先看一下源码：
package android.support.v4.util;
/**
* Helper class for creating pools of objects. An example use looks like this:
* <pre>
* 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);
* }
*
* . . .
* }
* </pre>
*
*/
public final class Pools {
/**
* Interface for managing a pool of objects.
*
* @param <T> The pooled type.
*/
public static interface Pool<T> {
/**
* @return An instance from the pool if such, null otherwise.
*/
public 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.
*/
public boolean release(T instance);
}
private Pools() {
/* do nothing - hiding constructor */
}
/**
* 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];
}
@Override
@SuppressWarnings("unchecked")
public T acquire() {
if (mPoolSize > 0) {
final int lastPooledIndex = mPoolSize - 1;
T instance = (T) mPool[lastPooledIndex];
mPool[lastPooledIndex] = null;
mPoolSize--;
return instance;
}
return null;
}
@Override
public boolean release(T instance) {
if (isInPool(instance)) {
throw new IllegalStateException("Already in the pool!");
}
if (mPoolSize < mPool.length) {
mPool[mPoolSize] = instance;
mPoolSize++;
return true;
}
return false;
}
private boolean isInPool(T instance) {
for (int i = 0; i < mPoolSize; i++) {
if (mPool[i] == instance) {
return true;
}
}
return false;
}
}
/**
* 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(T element) {
synchronized (mLock) {
return super.release(element);
}
}
}
}
我们看Pool接口，它定义了一个泛型T，两个方法分别是
T acquire();
和
boolean release(T instance);
第一个方法是获取一个泛型的实例，第二个方法是释放一个实例。从方法名我们即可一目了然，先不多说。
下面我们看一下其中一个实现类-SimplePool：
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];
}
@Override
@SuppressWarnings("unchecked")
public T acquire() {
if (mPoolSize > 0) {
final int lastPooledIndex = mPoolSize - 1;
T instance = (T) mPool[lastPooledIndex];
mPool[lastPooledIndex] = null;
mPoolSize--;
return instance;
}
return null;
}
@Override
public boolean release(T instance) {
if (isInPool(instance)) {
throw new IllegalStateException("Already in the pool!");
}
if (mPoolSize < mPool.length) {
mPool[mPoolSize] = instance;
mPoolSize++;
return true;
}
return false;
}
private boolean isInPool(T instance) {
for (int i = 0; i < mPoolSize; i++) {
if (mPool[i] == instance) {
return true;
}
}
return false;
}
}
这个类实现了Pool接口，复写了acquire和release方法。它定义了两个变量：
private final Object[] mPool;
private int mPoolSize;
第一个是Object的数组，用于存放具体的实例，mPoolSize是用于标记现在存放具体实例的数量。
接下来是构造函数，需要添加一个参数maxPoolSize，这个参数用于为Object数组初始化数组空间。为了避免浪费无用的空间，这个数字我们要事先预估一下，最多或最合适的是多少。
acquire方法分析
public T acquire() {
if (mPoolSize > 0) {
final int lastPooledIndex = mPoolSize - 1;
T instance = (T) mPool[lastPooledIndex];
mPool[lastPooledIndex] = null;
mPoolSize--;
return instance;
}
return null;
}
这个方法首先判断一下当前的Pool数组中是否有缓存的实例，如果没有直接返回null。否则计算一下最后一个缓存实例的下标，取出实例后，将数组中的缓存置空，缓存数量减1后返回取出的实例。
release方法分析
@Override
public boolean release(T instance) {
if (isInPool(instance)) {
throw new IllegalStateException("Already in the pool!");
}
if (mPoolSize < mPool.length) {
mPool[mPoolSize] = instance;
mPoolSize++;
return true;
}
return false;
}
private boolean isInPool(T instance) {
for (int i = 0; i < mPoolSize; i++) {
if (mPool[i] == instance) {
return true;
}
}
return false;
}
这个方法首先判断一下，需要释放的实例是否与当前缓存中有重复，如果有直接抛异常。这说明我们的同一个实例，不可以释放多次。然后判断一下缓存池是否已经存满，如果存满将不再操作，否则将实例存入缓存数组的最后。
大家能看的出来，这是一个点型的栈(FILO)结构，先进后出，不过这是什么结构也都无所谓，因为它什么结构也不会影响我们使用。
另一个实现，就是一个加锁的版本，做出线程安全，避免在多线程操作时出现异常情况，但同时性能也较差一些。这里不必细讲。
我们来说一下使用方法：
首先举个使用场景，比如生产啤酒的工厂：
- 在酒瓶中装满酒然后销售
- 有人买了酒，喝完后又把酒瓶卖回给工厂
- 工厂拿到酒瓶后清洗，然后又回到流程1中投入使用
我们创建一个瓶子类
public class Bottle {
// 啤酒
public String beer;
}
// 假设我们最多同时只能生产10瓶啤酒
private Pools.Pool<Bottle> mBottlePool = new Pools.SimplePool<>(10);
public Bottle acquire() {
// 使用缓存池获取一个实例
Bottle bottle = mBottlePool.acquire();
if (bottle == null) {
// 如果缓存池中没有缓存，那我们需要直接new一个
bottle = new Bottle();
}
return bottle;
}
public void release(Bottle bottle) {
if (bottle == null) return;
// 清空实例中的数据
bottle.beer = null;
// 通知缓存池，我们要释放一个实例，让缓存池收集缓存
mBottlePool.release(bottle);
}
到此，整个使用流程完成，这是一个很简单确很实用的工具类。希望大家能够在适当的场景中适当的使用，再好的工具，也不能滥用。
如有不明确，可在评论区留言！
