android 缓存池,Android 布局异步加载中的pools对象缓存池源码分析

前言

对象缓存池很多地方都用到，比比皆是。主要是供后续的应用程序重复使用，从而减少创建对象和释放对象的次数，进而改善应用程序的性能。

比如在：AsyncLayoutInflater的使用：

布局异步(AsyncLayoutInflater)加载中,对于AsyncLayoutInflater.InflateRequest的对象缓存。

public AsyncLayoutInflater.InflateRequest obtainRequest() {

//这里使用了对象缓存

AsyncLayoutInflater.InflateRequest obj = mRequestPool.acquire();

if (obj == null) {

obj = new AsyncLayoutInflater.InflateRequest();

}

return obj;

}

使用方法

来源官方class上面的的使用介绍，recycle(),这里可以对实例对象进行清洁，意思是初始化里面的字段，也可以不清洁，看需求吧。AsyncLayoutInflater实例对象缓存中的就做了初始化，再缓存实例对象，代码如下：

public void releaseRequest(InflateRequest obj) {

//重置一下实例对象

obj.callback = null;

obj.inflater = null;

obj.parent = null;

obj.resid = 0;

obj.view = null;

mRequestPool.release(obj);

}

使用方法，如下：

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

}

}

Pool接口的定义

来让我们看看这个Pool的接口，接口很简单，就2个方法。 acquire()主要是从缓存池中获取一个对象，这里可能为空。为空的情况：

1，对象缓存池中没有缓存对象，这种情况是对象池中没有放进任何对象。

2，对象池中对象被用完了。

release() 主要是释放一个对象到对象缓存池中，如果这个对象已经存在缓存池中，会抛出异常，如果缓存对象池已满，则返回false,不做任何操作。

public interface Pool {

/**从缓存池中返回一个对象，可能为空。

* @return An instance from the pool if such, null otherwise.

*/

@Nullable

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.

*/

boolean release(@NonNull T instance);

}

SimplePool的源码

具体的实现逻辑在SimplePool，但这里没有加锁，如需要加锁，使用SynchronizedPool即可。 缓存大小mPoolSize必须大于0，否则抛出异常。 调用acquire()时候，先判断mPoolSize是否大于0： 如果小于0，返回null。 如果大于0，证明对象池中还有可用对象，然后取一个使用，这个对象从数组中移出(后面release会把它再加回来，觉得这里设计好巧妙)。mPoolSize减一。返回缓存实例。

调用release(),会先调用isInPool()判断这个对象是否存在数组中，存在就抛出异常。因为acquire()时候已经把它移出了。主要防止一个对象重复保存到数组中，操作同一对象发生未知异常。 然后判断pool是否已满，如果没有存满，缓存一个对象，mPoolSize加一。如果存满，直接返回false。下面是SimplePool的源码。

public static class SimplePool implements Pool {

//线程池对象数组

private final Object[] mPool;

//线程池目前可用对象size，意思是还存在多少个对象在数组中。

private int mPoolSize;

/**

* Creates a new instance.

* 最大对象池size

* @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];

}

public T acquire() {

//判断 mPoolSize ，判断对象池是否已经用完了。用完了返回null

if (mPoolSize > 0) {

//取一个下标

final int lastPooledIndex = mPoolSize - 1;

//取出一个对象

T instance = (T) mPool[lastPooledIndex];

//把这个对象从数组中移出(后面release会把它再加回来)觉得这里设计好巧妙。

mPool[lastPooledIndex] = null;

//下标减1，意思是已经拿走一个去使用了。

mPoolSize--;

//返回对象

return instance;

}

//对象池用完了，返回null，让上层自己去新建一个吧

return null;

}

@Override

public boolean release(@NonNull T instance) {

//主要防止一个对象重复保存到数组中，判断这个对象是否存在数组中，存在就抛出异常。

//因为acquire()时候已经把它移出了。

if (isInPool(instance)) {

throw new IllegalStateException("Already in the pool!");

}

//如果没有存满，缓存一个对象。

if (mPoolSize < mPool.length) {

//把上面从数组中移出对象，再次保存回来。(移出保存是同一个哦)毕竟不是一次性的。

mPool[mPoolSize] = instance;

//池子大小加一

mPoolSize++;

return true;

}

//存满了，返回false ,这个上层可以针对这个做对应逻辑。

return false;

}

private boolean isInPool(@NonNull T instance) {

//查找这个对象是否存在数组中

for (int i = 0; i < mPoolSize; i++) {

if (mPool[i] == instance) {

return true;

}

}

return false;

}

}

如果需要同步

使用SynchronizedPool即可。

来让我们看看大致的流程图

流程图，丑是丑了点，将就看看吧！

image

最后

我将之前在网上收集整理了一小部分学习文档，由于文章的篇幅长度限制。更多的细节我已经上传至【GitHub项目】中！希望能对大家有所帮助。