Android Room 对象包含对象

文章目录

• 概述
• 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<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;
      }
  }