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

}

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

如有不明确,可在评论区留言!

  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值