内存优化(三)Android对象池使用

文章目录

    • 概述
    • Android Object Pools
        • Pools源码解析:
        • Pools结合Builder模式使用案例:
    • 使用总结和注意事项

概述

由内存优化(一)浅谈内存优化中看出,内存优化不仅要从防止内存泄露入手,也要注意频繁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 {
      
              /**
               * 获取对象
               */
              @Nullable
              T acquire();
      
              /**
               *释放对象
               */
              boolean release(@NonNull T instance);
          }
    
          private Pools() {
              /* do nothing - hiding constructor */
          }
      
          /**
           * 非同步对象池.
           */
          public static class SimplePool implements Pool {
              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 extends SimplePool {
              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 sPool =
                  new Pools.SimplePool(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;
          }
      }
    

你可能感兴趣的:(性能优化,软件性能优化)