Java的一个高性能快速深拷贝方法。Cloneable?

本人在设计数据库缓存层的时候,需要对数据进行深拷贝,这样用户操作的数据对象就是不共享的。

这个思路实际上和Erlang类似,就是用数据不共享解决并发问题。

 

1. 序列化?
原来的做法,是用序列化,我用了Json的序列化,lib-json。一个再传统不过的方法。把数据字段序列化成json保存。取出来的时候进行反序列化。

测试100条数据,100次循环,竟然TM的用了15秒。

这个是个啥概念?简直惨不忍睹。

于是网上搜,找到个Jackson,号称性能XXX的,比Google的gson高XXX。

替换之后,速度下降到3700ms。恩。有那么点意思。

但是才100次全查询,消耗了接近4秒,不可接受。

备注:

为什么不直接序列化?因为我设计表结构是变动的,使用json的key-value很容易进行表结构的扩展伸缩。

gson这货,竟然一步到位把json字符串转化成了对象。我只能说,太over-architecture了。过分的api设计了。

jackson使用了JsonNode,本质还是键值对,这种恰到好处的设计,非常方便。

结论:

如果要使用json, json-lib就是一坨屎,简直就是实验室作品。。。用jackson吧。

 

2. Cloneable接口?
我一向有个观点,Java提供的原生API性能一定比自己无论怎么搞也高效。

很可惜,Cloneable接口第一,没有public object clone。不知道他搞什么飞机。继承接口还不是public的。要自己调用object.clone. 第二,是浅拷贝,如果有对象数组,还是指针引用。

Usr_Equipment implements CLoneable

{

  @Override

  public Object clone() { super.clone();}
}

可惜了,真心不知道这个Cloneable设计出来是干什么的。

于是自己设计一个ICloneable extends Cloneable接口,把clone暴露出来。

 

3. 浅拷贝变成深拷贝?
为了实现深拷贝,必然需要使用递归对整个对象的属性遍历。整个魔法的核心,就是BeanCopier。性能比BeanMap更强大!我先放出代码:

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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
package com.xtar.common.structure;
 
import java.lang.reflect.Array;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
 
import net.sf.cglib.beans.BeanCopier;
import net.sf.cglib.core.Converter;
 
import com.xtar.common.interfaces.ICloneable;
import com.xtar.common.tool.ParserHelper;
 
public class CloneableBase implements ICloneable
{
    private static ConcurrentMap<Class<?>, BeanCopier> beanCopiers = new ConcurrentHashMap<Class<?>, BeanCopier>();
 
    @Override
    public Object clone()
    {
        try
        {
            Object clone = this.getClass().newInstance();
 
            BeanCopier copier = _createCopier(this.getClass());
 
            copier.copy(this, clone, new Converter()
            {
                @Override
                public Object convert(Object pojo, Class fieldType, Object fieldName)
                {
                    return _clone(pojo);
                }
            });
 
            return clone;
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
 
    private static Object _clone(Object bean)
    {
        if (bean == null)
        {
            return null;
        }
        else if (bean instanceof ICloneable)
        {
            return ((ICloneable) bean).clone();
        }
        else
        {
 
                    if (bean.getClass().isArray() && !bean.getClass().getComponentType().equals(byte.class))
                    {
                        int length = Array.getLength(bean);
                        Object clone = Array.newInstance(bean.getClass().getComponentType(), length);
                        for (int i = 0; i < length; i++)
                        {
                            Array.set(clone, i, _clone(Array.get(bean, i)));
                        }
                        return clone;
                    }
                    else
                    {
                        return bean;
                    }
            }
        }
    }
 
    private static BeanCopier _createCopier(Class<?> clz)
    {
        if (beanCopiers.containsKey(clz))
            return beanCopiers.get(clz);
        beanCopiers.putIfAbsent(clz, BeanCopier.create(clz, clz, true));
        return beanCopiers.get(clz);
 
    }
}
上面就是整个深拷贝的魔法核心。

1)使用了BeanCopier,并缓存这个对象,性能提升50%,从1s下降到600ms。

2)判断array,如果是byte[]类型,直接使用浅拷贝。这个是个特殊对象。

测试下来,比用BeanMap快2倍。相同的对象,BeanMap需要1700ms,而BeanCopier只需要500ms。

 

4. 结论
我自认为,这个方法已经做到极致了。(没测试二进制序列化)。只要自己的对象继承了CloneableBase,就能够实现深度拷贝。

 

posted @ 2016-10-21 20:02  华行天下  阅读(7408)  评论(0编辑  收藏