Android性能优化-对象池

对象池是一种设计模式，它会预先初始化一组可重用的实体，而不是按需销毁然后重建。在使用套接字描述符时，人们通常会将其池化。就像是一个对象管理员，它以Static列表（也就是装对象的池子）的形式存存储某个实例数受限的类的实例。

该博文主要会围绕一下几点来解释对象池：

• 什么时候改用对象池
• 对象池的分配触发和增长策略
• Coding

1、什么时候改用对象池

在大多数情况下，我们使用对象主要用来封装数据，要么是数据容器。作用是在应用程序和内部参数、通信或某些API充当一个信封。所以在我们优化我们的程序过程中，如果看到内存抖动或者后台不断有GC在执行的时候可以考虑使用对象池来管理；另外对象一次初始化大量的实例，导致系统迟滞，并且伴有GC中断也可以考虑引入对象池管理。

2、对象池的分配触发和增长策略

• 分配触发

        对象池的分配触发主要有：空池触发、水位线、Lease/Return速度

        a.空池触发：任何时候，只要池空了，就分配对象。这是一种最简单的方式。

        b.水位线：设置警戒线，达到设定的某个警戒线时就分配对象

        c.Lease/Return速度：大多数时候，水位线触发已经足够，但有时候可能会需要更高的精度。例如，          如果池中有100个对象，每秒有20个对象被取走，但只有10个对象返回，那么9秒后池就空了。开发            者可以使用这种信息，提前做好对象分配计划。

• 增长策略

        用于指定分配过程被触发后需要分配的对象的数量。

        a.固定大小

        a.小步增长：为了避免出现某次对象请求会因为执行对象分配而中断，每次取的时候额外的分配一个            对象       

3、举例说明

• JAVA版本：

//调用
ObjectPool op = new ObjectPool();
op.createPool();
TaskPool tPool = op.getTask();
System.out.println("tPool:" + tPool);
op.closePool();

控制台输出：

tPool:com.xxx.TaskPool@7852e922

完整代码如下：

package com.huashengmi.rxf.op;

import java.util.ArrayList;
import java.util.List;

/**
 * @Email: huangsanm@foxmail.com
 * @Date: 2016年12月7日
 * @Time: 下午3:57:27
 * 对象池
 */
public class ObjectPool {

	//对象池初始大小
	private final static int POOL_SIZE = 8;
	//对象池警戒线,如果递增3
	private final static int POOL_LINE = 6;
	
	//缓存对象
	private List<TaskPool> mTaskPools;
	
	
	/**
	 * 初始化对象池
	 */
	public synchronized void createPool(){
		if (mTaskPools == null) {
			mTaskPools = new ArrayList<TaskPool>();
		}
		
		//初始化对象
		for (int i = 0; i < POOL_SIZE; i++) {
			TaskPool tp = new TaskPool();
			mTaskPools.add(tp);
		}
	}
	
	/**
	 * 从对象池中获取对象
	 * @return
	 */
	public TaskPool getTask(){
		if (mTaskPools == null) {
			throw new RuntimeException("object's pool not init...");
		}
		TaskPool taskPool = null;
		final int size = mTaskPools.size();
		for (int i = 0; i < size; i++) {
			TaskPool tp = mTaskPools.get(i);
			if (!tp.isUsing) {
				//取到对象退出
				tp.isUsing = true;
				taskPool = tp;
				break;
			}
		}
		
		//取完之后检查池里面的对象是否达到警戒线
		int useTaskNum = 0;
		for (int i = 0; i < size; i++) {
			TaskPool tp = mTaskPools.get(i);
			if (tp.isUsing) {
				useTaskNum ++;
			}
		}
		
		//增加对象池中对象
		if (useTaskNum >= POOL_LINE) {
			//初始化对象
			for (int i = 0; i < 3; i++) {
				TaskPool tp = new TaskPool();
				mTaskPools.add(tp);
			}
		}
		
		return taskPool;
	}
	
	/**
	 * 回收对象池的对象
	 * @param tp
	 */
	public void releaseTaskPool(TaskPool task){
		final int size = mTaskPools.size();
		for (int i = 0; i < size; i++) {
			TaskPool tp = mTaskPools.get(i);
			if (tp == task) {
				tp.isUsing = false;
				mTaskPools.set(i, tp);
				break;
			}
		}
	}
	
	/**
	 * 关闭对象池
	 */
	public void closePool(){
		mTaskPools.clear();
		mTaskPools = null;
	}
	
	
}

• Android版对象池：

public class TaskPool {

  public String id;
  public String name;

  private static final SynchronizedPool<TaskPool> sPool = new SynchronizedPool<TaskPool>(
          10);

  public static TaskPool obtain() {
      TaskPool instance = sPool.acquire();
      return (instance != null) ? instance : new TaskPool();
  }

  public void recycle() {
      sPool.release(this);
  }
}

调用

//从对象池中获取，第一次对象池没有，会直接new一个,如果有会复用
TaskPool tpool = TaskPool.obtain();

//使用完毕务必要将对象归还到对象池
tPool.recycle();

谢谢打赏：前者支付宝，后者微信

转载于:https://my.oschina.net/huangsm/blog/801581