0

我在序列化和反序列化同一 JVM 中的对象列表时遇到问题。确切地说，现在我的对象拥有对对象的相同引用，该Alphabet对象具有以下规则：

    VMID instanceId = new VMID();  //used in readResolve to identify persitent instances

    public Alphabet (int capacity, Class entryClass) {
        this.map = new gnu.trove.TObjectIntHashMap (capacity);
        this.entries = new ArrayList (capacity);
        this.entryClass = entryClass;
        // someone could try to deserialize us into this image (e.g., by RMI).  Handle this.
        deserializedEntries.put (instanceId, this);
    }

    public VMID getInstanceId() {
        return instanceId;
    } // for debugging

    public void setInstanceId(VMID id) { this.instanceId = id; }

    // Serialization
    private static final long serialVersionUID = 1;

    private static final int CURRENT_SERIAL_VERSION = 1;

    private void writeObject (ObjectOutputStream out) throws IOException {
        out.writeInt (CURRENT_SERIAL_VERSION);
        out.writeInt (entries.size());
        for (int i = 0; i < entries.size(); i++) {
            out.writeObject (entries.get(i));
        }
        out.writeBoolean (growthStopped);
        out.writeObject (entryClass);
        out.writeObject(instanceId);
    }

    private void readObject (ObjectInputStream in) throws IOException, ClassNotFoundException {
        int version = in.readInt ();
        int size = in.readInt();
        entries = new ArrayList (size);
        map = new gnu.trove.TObjectIntHashMap (size);
        for (int i = 0; i < size; i++) {
            Object o = in.readObject();
            map.put (o, i);
            entries. add (o);
        }
        growthStopped = in.readBoolean();
        entryClass = (Class) in.readObject();
        if (version >0 ){ // instanced id added in version 1S
            instanceId = (VMID) in.readObject();
        }
    }

    private transient static HashMap deserializedEntries = new HashMap();
    /**
     * This gets called after readObject; it lets the object decide whether
     * to return itself or return a previously read in version.
     * We use a hashMap of instanceIds to determine if we have already read
     * in this object.
     * @return
     * @throws ObjectStreamException
     */

    public Object readResolve() throws ObjectStreamException {
        Object previous = deserializedEntries.get(instanceId);
        if (previous != null){
            //System.out.println(" ***Alphabet ReadResolve:Resolving to previous instance. instance id= " + instanceId);
            return previous;
        }
        if (instanceId != null){
            deserializedEntries.put(instanceId, this);
        }
        //System.out.println(" *** Alphabet ReadResolve: new instance. instance id= " + instanceId);
        return this;
    }

现在在我的对象列表反序列化之后，在某些时候 Alphabet 引用不匹配。我使用以下方法进行了检查：

for (Instance i: finalTrainingDocs){
    if (!i.getTargetAlphabet().equals(finalTraining.getTargetAlphabet())){
        System.out.println("not equals");
        System.out.println(i.getTargetAlphabet().getInstanceId() + " " + finalTraining.getTargetAlphabet().getInstanceId());
    }
    finalTraining.add(i);
    counter++;
    System.out.println("counter " + counter);
}

并得到以下结果

counter 237
counter 238
counter 239
not equals
3ce62156867eb540:6b7f0de5:141e51fcd67:-7ffa 3ce62156867eb540:6b7f0de5:141e51fcd67:-7ffa

现在看看 VMId，因为它们是相同的，所以它不应该是同一个对象，就像上面的逻辑一样？感谢您的帮助。

4

2 回答 2

0

一种可能性是您有竞争条件；即两个线程同时更新deserializedEntrieshashmap。这可能会导致您拥有两个具有相同值的Alphabet实例。instanceId

声明deserializedEntriesasvolatile不足以防止这种情况发生。（事实上​​，您不充分的同步甚至可能导致 hashmap 的内部数据结构被破坏。）

我不相信你正在做的是一个好主意。除了这种脆弱性（需要更多的重量级同步来修复）之外，您还面临哈希映射是内存泄漏的问题。我怀疑你会通过接受Alphabet实例被重复并覆盖equals来处理这个问题来获得更好的性能。

于 2013-10-23T12:06:25.263 回答
-1

您正在阅读基于版本的 instanceId

if (version >0 ){ // instanced id added in version 1S
    instanceId = (VMID) in.readObject();
}

所以这里需要同样的条件

 if (CURRENT_SERIAL_VERSION >0 ){ 
      out.writeObject(instanceId);
于 2013-10-23T11:58:16.690 回答