如需转载请评论或简信，并注明出处，未经允许不得转载
目录
前言
内存优化不仅要从防止内存泄露入手，也要注意频繁GC卡顿，内存抖动以及不必要的内存开销造成的内存需求过大或者内存泄露。而避免内存无用开销就必须理解Android开发中的一个重要原则 — 对象复用
有关内存抖动产生原因可以看：五分钟了解内存抖动
Android源码中的对象池技术—Message
Android系统基于消息机制，Handle的使用方法我们已经很熟悉了，主要分为如下几步：
在主线程创建
handler对象在子线程中将需要被发送的数据用
Message对象进行封装在子线程中调用
handle.sendMessage方法发送消息在主线程中通过
handler.handleMessage接收消息
那么问题来了，当项目比较复杂频繁用到handle发送消息的时候，是不是意味着就会创建大量的Message对象呢？Message是用来存储消息的一个对象，很多时候它的”生命周期“往往是比较短暂的，但是如果gc并不能把Message及时回收，是不是造成了内存资源的浪费呢？即使gc在不断地及时进行回收，也有可能造成一定程度的内存抖动，那么我们有什么比较好的办法呢？
Message相关变量介绍
-
public int what：用于定义此Message属于何种操作，以便用不同方式处理message -
public Object obj：用于定义此Message传递的信息数据，通过它传递信息 -
public int arg1：传递一些整型数据时使用 -
public int arg2：传递一些整型数据时使用
如果message只需要携带int类型信息，优先使用Message.arg1和Message.arg2来传递信息，会比用Bundle更省内存
Message对象创建方式
Message msg = new Message();
最普通的方式是通过构造方法创建，这样在大量发送消息时就会造成我们前面说过的内存问题，这里就不过多介绍了
Message msg = Message.obtain();Message msg = Handler.obtainMessage();
比较推荐使用这种方式，具体原理我们一点点来分析
Message next;
private static final Object sPoolSync = new Object();
private static Message sPool;
private static int sPoolSize = 0;
private static final int MAX_POOL_SIZE = 50;
/**
* Return a new Message instance from the global pool. Allows us to
* avoid allocating new objects in many cases.
*/
public static Message obtain() {
synchronized (sPoolSync) {
if (sPool != null) {
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0; // clear in-use flag
sPoolSize--;
return m;
}
}
return new Message();
}
从注释中我们基本就可以看出这个方法的作用，从全局pool中返回一个Message对象，这个方法可以让我们在许多情况下避免分配新对象。从代码中我们大致可以看出Message是一种链表的结构，包含数据域和指针域
假设链表的初始状态
Message m = sPool;
sPool = m.next;
m.next = null;
m.flags = 0;
清除 in-use 标识
sPoolSize--;
Message Pool 的计数自减
return m;
最终m指向的对象会从链表中取出并返回
上面这个过程是一个从Message Pool中取出Message的过程（出栈），那么Message pool中的message是如何增加的呢（入栈）？
我们来看Message回收的方法，在释放完Message内部的一些资源后，我们主要来关注下面这个同步代码块
/**
* Recycles a Message that may be in-use.
* Used internally by the MessageQueue and Looper when disposing of queued Messages.
*/
void recycleUnchecked() {
// Mark the message as in use while it remains in the recycled object pool.
// Clear out all other details.
flags = FLAG_IN_USE;
what = 0;
arg1 = 0;
arg2 = 0;
obj = null;
replyTo = null;
sendingUid = -1;
when = 0;
target = null;
callback = null;
data = null;
synchronized (sPoolSync) {
if (sPoolSize < MAX_POOL_SIZE) {
next = sPool;
sPool = this;
sPoolSize++;
}
}
}
假设链表的初始状态
next = sPool
sPool = this;
从上面obtain()和recycler()两个过程可以看出，Message类内部维护了一个用单链表实现的栈结构的缓冲池，并使用obtain()方法和recycler()方法进行出栈和入栈操作
如何在实际项目中使用对象池技术
Android为我们提供了一个对象池类androidx.core.util.Pools（或android.support.v4.util.Pools），源码如下
package androidx.core.util;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
public final class Pools {
/**
* Interface for managing a pool of objects.
*
* @param <T> The pooled type.
*/
public interface Pool<T> {
/**
* @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);
}
private Pools() {
/* do nothing - hiding constructor */
}
/**
* Simple (non-synchronized) pool of objects.
*
* @param <T> The pooled type.
*/
public static class SimplePool<T> implements Pool<T> {
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(@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;
}
}
/**
* Synchronized) pool of objects.
*
* @param <T> The pooled type.
*/
public static class SynchronizedPool<T> extends SimplePool<T> {
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(@NonNull T element) {
synchronized (mLock) {
return super.release(element);
}
}
}
}
源码很简单，主要有Pool接口、SimplePool、SynchronizedPool组成
原理：使用了“懒加载”的思想。当SimplePool初始化时，不会生成N个T类型的对象存放在对象池中。而是当每次外部调用release()时，才把释放的T类型对象存放在对象池中。要先放入，才能取出来
官方给出的使用Demo如下
public class MyPooledClass {
private static final SynchronizedPool<MyPooledClass> sPool =
new SynchronizedPool<MyPooledClass>(10);
public static MyPooledClass obtain() {
MyPooledClass instance = sPool.acquire();
return (instance != null) ? instance : new MyPooledClass();
}
public void recycle() {
sPool.release(this);
}
}
但是它也有弊端，对象池没有最终销毁机制，应该需要的注意点：
recycle对象时注意清空对象的变量
当对象池满时，获取对象便只能通过new对象获取，所以应该注意对象大小设定
当长时间不使用对象池时应该注意销毁对象池
public void destoryPool() {
if (sPool != null) {
sPool = null;
}
}
总结
在一些需要大量创建对象的场景下，慎用new！可能引起的内存问题比你想象的还要更大，可以考虑一下使用对象池来进行优化
