android+对象池使用,Android开发中对高并发对象池的重复利用

这两天在整理一套Android的路由框架，在整理的过程中，发现在路由消息传递过程中，传输载体类会大量的生成，对于这种载体类来说，他们本身是可重复利用的，并不需要大量的创建，大量的废弃，所以，我打算引入对象池，来解决类的重复创建问题。 对象的生命周

这两天在整理一套Android的路由框架，在整理的过程中，发现在路由消息传递过程中，传输载体类会大量的生成，对于这种载体类来说，他们本身是可重复利用的，并不需要大量的创建，大量的废弃，所以，我打算引入对象池，来解决类的重复创建问题。

对象的生命周期

Java对象的生命周期大致包括三个阶段：对象的创建，对象的使用，对象的清除。因此，对象的生命周期长度可用如下的表达式表示：T = T1 + T2 +T3。其中T1表示对象的创建时间，T2表示对象的使用时间，而T3则表示其清除时间。由此，我们可以看出，只有T2是真正有效的时间，而T1、T3则是对象本身的开销。所以，避免和减少T1和T3的时间，能有效的提升程序的性能。

对象池

在EffectJava的第五条建议中，明确给出了“避免创建不必要的对象”这样的建议。对于可重复利用的对象，我们不应该频繁的创建销毁，而是应该反复利用。

重复利用对象，我们就需要建一个对象池，把所有可复用的对象都统一放到池中，同时对外提供obtain()方法来获取对象。通常，我们利用静态对象数组来实现对象池。

对象池的初始化策略分为两种，一种是统一初始化，即在特定时机统一初始化池内所有对象，第一次使用的时候会有一定的开销。另一种是即时初始化，就是在使用中进行初始化，每次都会有一定的开销，直到池内充满。

高并发

在对象池创建好之后，我们就需要考虑如何分配、回收对象池的对象了。由于是路由系统的载体类，所以势必会有多线程进行访问，我们还要考虑到线程安全，以及并发性能。

关于线程安全，一般的做法是通过synchronized关键字来进行线程同步。不过这么做的话，相当于是对obtain()函数加了悲观锁。这么做虽然可以有效的防止同步问题，而且synchronized关键字也经过了JVM多次性能优化，不过，在性能上依然不能满足高并发的要求。

这时候我们参考可以参考ConcurrentHashMap，利用CAS算法(非阻塞同步算法)实现乐观锁。我们在类中创建一个AtomicBoolean变量，命名为isIdle，默认值为true(空闲状态)，当多个线程去争抢一个对象的时候，会调用isIdle.compareAndSet(true,false)，该方法会返回boolean类型的结果，如果返回true，则表明竞争成功，isIdle被设置为false(占用中)，如果返回false，则表明该类已经被别的线程所占用，重新申请另外的对象，直到该对象的isIdle竞争成功。

相关代码如下：

// 顺序计数器

private static AtomicInteger sIndex;

// 空闲标识

AtomicBoolean isIdle;

// 计数器重置参数

private static final int RESET_NUM = 1000;

public static ConcurrentRouterRequest obtain(){

// 获取下一个计数器的值

int index = sIndex.getAndIncrement();

// 如果计数器过大，则置0

if(index>RESET_NUM){

sIndex.compareAndSet(index,0);

if(index>RESET_NUM*2){

sIndex.set(0);

}

}

// 计算计数器对应对象数组的对象下标

int num = index&(length-1);

// 获取对应对象

ConcurrentRouterRequest target = table[num];

// 竞争该对象的空闲标识，其中第一个参数true是我们希望的值，第二个参数是需要设置的值false。

// 如果设置成功，那么直接返回target，如果失败，则继续寻找下一个空闲的对象。

if(target.isIdle.compareAndSet(true,false)){

return target;

}else{

return obtain();

}

}

这里要说一下，关于对象池如何分配对象的问题，这里采用的是顺序分配，每次获取都会在对象池中往后顺延一位。同时，对象池的长度默认为2的N次方，这样做的好处是通过按位与计算，能快速找出对象池中的数组下标，这个模仿了HashMap中的Hash值存储。

测试对比

模拟的条件是100条线程并发请求，每单个线程请求1000次，总计十万次并发。

时间开销

内存开销

新建对象

220ms

1.53MB

利用对象池

180ms

1.25KB

第一种情况是直接用new关键字新建对象，处理请求，最后的结果是耗时220ms，内存消耗100000*16(byte)=1.53MB。

第二种情况是使用对象池处理请求，最后耗时180ms，内存消耗为64*20(byte)=1.25KB。

通过对比我们可以看出，首先，由于减少了对象的创建，虽然多了同步，不过在时间性能上，对象池还是优于新建对象，大概提升了20%左右的性能。该时间还不包括GC回收的开销，如果加上的话，性能提升会更明显。其次，在内存上面，两者的差距是1000倍左右的，极大地节省了内存的开销，减少了GC的触发。

对象池实现

下面放一个纯Java实现的高并发对象池

对象池：

public final class ObjectPool {

private OBJECT[] mTable;

private AtomicInteger mOrderNumber;

public static int RESET_NUM = 1000;

public ObjectPool(OBJECT[] inputArray) {

mOrderNumber = new AtomicInteger(0);

mTable = inputArray;

if (mTable == null) {

throw new NullPointerException("The input array is null.");

}

int length = inputArray.length;

if ((length & length - 1) != 0) {

throw new RuntimeException("The length of input array is not 2^n.");

}

}

public void recycle(OBJECT object) {

object.isIdle.set(true);

}

public OBJECT obtain() {

int index = mOrderNumber.getAndIncrement();

if (index > RESET_NUM) {

mOrderNumber.compareAndSet(index, 0);

if (index > RESET_NUM * 2) {

mOrderNumber.set(0);

}

}

int num = index & (mTable.length - 1);

OBJECT target = mTable[num];

if (target.isIdle.compareAndSet(true, false)) {

return target;

} else {

// 注意：此处可能会因为OBJECT回收不及时，而导致栈溢出。

// 请增加retryTime参数，以及retryTime过多后的判断。

// 具体思路请参考

// https://github.com/SpinyTech/ModularizationArchitecture/blob/master/macore/src/main/java/com/spinytech/macore/router/RouterRequest.java

// 中的obtain()及obtain(int retryTime);方法

return obtain();

}

}

public abstract static class RecyclableObject {

AtomicBoolean isIdle = new AtomicBoolean(true);

}

}

测试类：

public class Test {

public static void main(String[] args) {

TestObject[] array = new TestObject[32];

for(int i = 0 ; i < 32 ;i++){

array[i] = new TestObject();

}

final ObjectPool objectPool = new ObjectPool<>(array);

for(int i = 0 ; i < 50; i++){

new Thread("Thread:"+i){

@Override

public void run() {

super.run();

for(int j = 0 ; j < 50 ; j++){

TestObject testObject = objectPool.obtain();

testObject.print(getName(),"--index:"+j);

objectPool.recycle(testObject);

}

}

}.start();

}

}

static class TestObject extends ObjectPool.RecyclableObject{

public TestObject(){

}

public void print(String thread, String index){

System.out.println(thread+index);

}

}

}