概述
由内存优化（一）浅谈内存优化中看出，内存优化不仅要从防止内存泄露入手，也要注意频繁GC卡顿，内存抖动以及不必要的内存开销造成的内存需求过大或者内存泄露。而避免内存无用开销就必须理解Android开发中的一个重要原则——对象复用。
对象复用在我们开发中使用的案例很多，Adapter就是这个原则的着重体现。本文主要写的是Android对象池的使用，在一些请求框架中可能会用到，频繁创建Request Bean对象，这时，对象池就显得尤为重要了，它能很好的复用对象，避免频繁创建和销毁。
Android Object Pools
Android对象池是由Android源码中提供的一个类：android.support.v4.util.Pools，常规的使用对象池我们都可以通过它实现，它的源码也很简单，如下：
Pools源码解析：
Pools中主要实现2个接口：acquire（从池中获取对象），release（释放对象，存入池中）
2个内部类，分别是SimplePool和SynchronizedPool，SynchronizedPool是继承SimplePool，里面通过Synchronized同步锁实现一个安全的对象池
Pools通过维持一个对象数组，存入复用对象，当数组满了便只能创建新的对象
-
Pools有个很好的特点：它并不需要预先创建对象到对象池，它需要在release方法中将回收对象添加到复用的对象池中
public final class Pools { public interface Pool<T> { /** * 获取对象 */ @Nullable T acquire(); /** *释放对象 */ boolean release(@NonNull T instance); } private Pools() { /* do nothing - hiding constructor */ } /** * 非同步对象池. */ public static class SimplePool<T> implements Pool<T> { private final Object[] mPool; private int mPoolSize; /** * 创建一个对象池，并指定最大存入对象数量 */ 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(@NonNull 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(@NonNull T instance) { for (int i = 0; i < mPoolSize; i++) { if (mPool[i] == instance) { return true; } } return false; } } /** * 同步对象池 */ public static class SynchronizedPool<T> extends SimplePool<T> { private final Object mLock = new Object(); public SynchronizedPool(int maxPoolSize) { super(maxPoolSize); } @Override public T acquire() { //通过synchronized实现同步 synchronized (mLock) { return super.acquire(); } } @Override public boolean release(@NonNull T element) { synchronized (mLock) { return super.release(element); } } } }
Pools结合Builder模式使用案例：
- 创建一个请求对象，当参数较多时结合Builder模式一起使用：
CtlRequestObj builder = new CtlRequestObj.Builder().setCmd(1).setState(0).setParam(2).builder(); - CtlRequestObj ：
/**
* Created by Felix on 15/12/12.
*/
public class CtlRequestObj {
private int cmd;
private int param;
private int state;
public int getCmd() {
return cmd;
}
public void setCmd(int cmd) {
this.cmd = cmd;
}
public int getParam() {
return param;
}
public void setParam(int param) {
this.param = param;
}
public int getState() {
return state;
}
public void setState(int state) {
this.state = state;
}
private CtlRequestObj() {
}
/**
* 初始化对象状态
*/
private void releaseConfig() {
cmd = 0;
param = 0;
state = 0;
}
/**
* 回收对象：初始化对象-->存入对象池
*/
public void recycle() {
// Clear state if needed.
this.releaseConfig();
sPool.release(this);
}
//初始化线程池
private static final Pools.SimplePool<CtlRequestObj> sPool =
new Pools.SimplePool<CtlRequestObj>(Constants.CTR_REQUEST_BEANS_SPOOL_SIZE);
/**
* 获取（创建对象）
* 默认从对象池中获取，拿不到就new
*
* @return
*/
public static CtlRequestObj obtain() {
CtlRequestObj instance = sPool.acquire();
return (instance != null) ? instance : new CtlRequestObj();
}
/**
* 通过Builder模式创建
*/
public static class Builder {
private int cmd;
private int param;
private int state;
public Builder() {
}
public CtlRequestObj.Builder setCmd(int cmd) {
this.cmd = cmd;
return this;
}
public CtlRequestObj.Builder setState(int state) {
this.state = state;
return this;
}
public CtlRequestObj.Builder setParam(int param) {
this.param = param;
return this;
}
private void applyConfig(CtlRequestObj config) {
config.cmd = this.cmd;
config.param = this.param;
config.state = this.state;
}
public CtlRequestObj builder() {
CtlRequestObj obtain = CtlRequestObj.obtain();
applyConfig(obtain);
return obtain;
}
}
}
使用总结和注意事项
Android对象池的源码非常简单，我们能够自己封装也能自己去实现，对象池的应用很广泛，比如Message和Glide中都有用到。我们自己在使用中，大部分简单的使用都可以通过Android提供的SimplePool和SynchronizedPool去实现，但是它也有弊端，对象池没有最终销毁机制，所以我们如果使用应该注意销毁对象池。
应该需要的注意点：
recycle对象时注意清空对象的变量
当对象池满时，获取对象便只能通过new对象获取，所以应该注意对象大小设定
-
当长时间不使用对象池时应该注意销毁对象池
public void destoryPool() { if (sPool != null) { sPool = null; } }
