内存优化（三）Android对象池使用

概述

由内存优化（一）浅谈内存优化中看出，内存优化不仅要从防止内存泄露入手，也要注意频繁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;
        }
    }