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. 在酒瓶中装满酒然后销售
  2. 有人买了酒,喝完后又把酒瓶卖回给工厂
  3. 工厂拿到酒瓶后清洗,然后又回到流程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);
 }

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

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

你可能感兴趣的:(Android实例缓存池-Pools分析)