android 缓存池,Android实例缓存池-Pools分析

在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:

*

* public class MyPooledClass {

*

* private static final SynchronizedPool sPool =

* new SynchronizedPool(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);

* }

*

* . . .

* }

*

*

*/

public final class Pools {

/**

* Interface for managing a pool of objects.

*

* @param The pooled type.

*/

public static interface Pool {

/**

* @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 The pooled type.

*/

public static class SimplePool implements Pool {

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 The pooled type.

*/

public static class SynchronizedPool extends SimplePool {

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 implements Pool {

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 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);

}

到此，整个使用流程完成，这是一个很简单确很实用的工具类。希望大家能够在适当的场景中适当的使用，再好的工具，也不能滥用。

如有不明确，可在评论区留言！