概述
内存优化不仅要从防止内存泄露入手，也要注意频繁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;
}
}
作者：Felix_lin
链接：https://www.jianshu.com/p/72293c236488
来源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
网友评论