这两天在整理一套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竞争成功。

相关代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// 顺序计数器
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实现的高并发对象池

对象池:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
public final class ObjectPool<OBJECT extends ObjectPool.RecyclableObject> {
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);
}
}

测试类:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
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<TestObject> 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);
}
}
}

原创文章,转载请先联系作者:spiny.tech@gmail.com